diff options
Diffstat (limited to 'engine/src/bullet-native/jmePhysicsSpace.cpp')
-rw-r--r-- | engine/src/bullet-native/jmePhysicsSpace.cpp | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/engine/src/bullet-native/jmePhysicsSpace.cpp b/engine/src/bullet-native/jmePhysicsSpace.cpp new file mode 100644 index 0000000..f5e97ea --- /dev/null +++ b/engine/src/bullet-native/jmePhysicsSpace.cpp @@ -0,0 +1,275 @@ +/* + * 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. + */ +#include "jmePhysicsSpace.h" +#include "jmeBulletUtil.h" +#include <stdio.h> + +/** + * Author: Normen Hansen + */ +jmePhysicsSpace::jmePhysicsSpace(JNIEnv* env, jobject javaSpace) { + //TODO: global ref? maybe not -> cleaning, rather callback class? + this->javaPhysicsSpace = env->NewWeakGlobalRef(javaSpace); + this->env = env; + env->GetJavaVM(&vm); + if (env->ExceptionCheck()) { + env->Throw(env->ExceptionOccurred()); + return; + } +} + +void jmePhysicsSpace::attachThread() { +#ifdef ANDROID + vm->AttachCurrentThread((JNIEnv**) &env, NULL); +#elif defined (JNI_VERSION_1_2) + vm->AttachCurrentThread((void**) &env, NULL); +#else + vm->AttachCurrentThread(&env, NULL); +#endif +} + +JNIEnv* jmePhysicsSpace::getEnv() { + attachThread(); + return this->env; +} + +void jmePhysicsSpace::stepSimulation(jfloat tpf, jint maxSteps, jfloat accuracy) { + dynamicsWorld->stepSimulation(tpf, maxSteps, accuracy); +} + +btThreadSupportInterface* jmePhysicsSpace::createSolverThreadSupport(int maxNumThreads) { +#ifdef _WIN32 + Win32ThreadSupport::Win32ThreadConstructionInfo threadConstructionInfo("solverThreads", SolverThreadFunc, SolverlsMemoryFunc, maxNumThreads); + Win32ThreadSupport* threadSupport = new Win32ThreadSupport(threadConstructionInfo); + threadSupport->startSPU(); +#elif defined (USE_PTHREADS) + PosixThreadSupport::ThreadConstructionInfo constructionInfo("collision", SolverThreadFunc, + SolverlsMemoryFunc, maxNumThreads); + PosixThreadSupport* threadSupport = new PosixThreadSupport(constructionInfo); + threadSupport->startSPU(); +#else + SequentialThreadSupport::SequentialThreadConstructionInfo tci("solverThreads", SolverThreadFunc, SolverlsMemoryFunc); + SequentialThreadSupport* threadSupport = new SequentialThreadSupport(tci); + threadSupport->startSPU(); +#endif + return threadSupport; +} + +btThreadSupportInterface* jmePhysicsSpace::createDispatchThreadSupport(int maxNumThreads) { +#ifdef _WIN32 + Win32ThreadSupport::Win32ThreadConstructionInfo threadConstructionInfo("solverThreads", processCollisionTask, createCollisionLocalStoreMemory, maxNumThreads); + Win32ThreadSupport* threadSupport = new Win32ThreadSupport(threadConstructionInfo); + threadSupport->startSPU(); +#elif defined (USE_PTHREADS) + PosixThreadSupport::ThreadConstructionInfo solverConstructionInfo("solver", processCollisionTask, + createCollisionLocalStoreMemory, maxNumThreads); + PosixThreadSupport* threadSupport = new PosixThreadSupport(solverConstructionInfo); + threadSupport->startSPU(); +#else + SequentialThreadSupport::SequentialThreadConstructionInfo tci("solverThreads", processCollisionTask, createCollisionLocalStoreMemory); + SequentialThreadSupport* threadSupport = new SequentialThreadSupport(tci); + threadSupport->startSPU(); +#endif + return threadSupport; +} + +void jmePhysicsSpace::createPhysicsSpace(jfloat minX, jfloat minY, jfloat minZ, jfloat maxX, jfloat maxY, jfloat maxZ, jint broadphaseId, jboolean threading) { + // collision configuration contains default setup for memory, collision setup + btDefaultCollisionConstructionInfo cci; + // if(threading){ + // cci.m_defaultMaxPersistentManifoldPoolSize = 32768; + // } + btCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration(cci); + + btVector3 min = btVector3(minX, minY, minZ); + btVector3 max = btVector3(maxX, maxY, maxZ); + + btBroadphaseInterface* broadphase; + + switch (broadphaseId) { + case 0: + broadphase = new btSimpleBroadphase(); + break; + case 1: + broadphase = new btAxisSweep3(min, max); + break; + case 2: + //TODO: 32bit! + broadphase = new btAxisSweep3(min, max); + break; + case 3: + broadphase = new btDbvtBroadphase(); + break; + case 4: + // broadphase = new btGpu3DGridBroadphase( + // min, max, + // 20, 20, 20, + // 10000, 1000, 25); + break; + } + + btCollisionDispatcher* dispatcher; + btConstraintSolver* solver; + // use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded) + if (threading) { + btThreadSupportInterface* dispatchThreads = createDispatchThreadSupport(4); + dispatcher = new SpuGatheringCollisionDispatcher(dispatchThreads, 4, collisionConfiguration); + dispatcher->setDispatcherFlags(btCollisionDispatcher::CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION); + } else { + dispatcher = new btCollisionDispatcher(collisionConfiguration); + } + + // the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded) + if (threading) { + btThreadSupportInterface* solverThreads = createSolverThreadSupport(4); + solver = new btParallelConstraintSolver(solverThreads); + } else { + solver = new btSequentialImpulseConstraintSolver; + } + + //create dynamics world + btDiscreteDynamicsWorld* world = new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration); + dynamicsWorld = world; + dynamicsWorld->setWorldUserInfo(this); + + //parallel solver requires the contacts to be in a contiguous pool, so avoid dynamic allocation + if (threading) { + world->getSimulationIslandManager()->setSplitIslands(false); + world->getSolverInfo().m_numIterations = 4; + world->getSolverInfo().m_solverMode = SOLVER_SIMD + SOLVER_USE_WARMSTARTING; //+SOLVER_RANDMIZE_ORDER; + world->getDispatchInfo().m_enableSPU = true; + } + + broadphase->getOverlappingPairCache()->setInternalGhostPairCallback(new btGhostPairCallback()); + + dynamicsWorld->setGravity(btVector3(0, -9.81f, 0)); + + struct jmeFilterCallback : public btOverlapFilterCallback { + // 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); + 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) { + jmePhysicsSpace* dynamicsWorld = (jmePhysicsSpace*) world->getWorldUserInfo(); + JNIEnv* env = dynamicsWorld->getEnv(); + jobject javaPhysicsSpace = env->NewLocalRef(dynamicsWorld->getJavaPhysicsSpace()); + if (javaPhysicsSpace != NULL) { + env->CallVoidMethod(javaPhysicsSpace, jmeClasses::PhysicsSpace_preTick, timeStep); + env->DeleteLocalRef(javaPhysicsSpace); + if (env->ExceptionCheck()) { + env->Throw(env->ExceptionOccurred()); + return; + } + } +} + +void jmePhysicsSpace::postTickCallback(btDynamicsWorld *world, btScalar timeStep) { + jmePhysicsSpace* dynamicsWorld = (jmePhysicsSpace*) world->getWorldUserInfo(); + JNIEnv* env = dynamicsWorld->getEnv(); + jobject javaPhysicsSpace = env->NewLocalRef(dynamicsWorld->getJavaPhysicsSpace()); + if (javaPhysicsSpace != NULL) { + env->CallVoidMethod(javaPhysicsSpace, jmeClasses::PhysicsSpace_postTick, timeStep); + env->DeleteLocalRef(javaPhysicsSpace); + if (env->ExceptionCheck()) { + env->Throw(env->ExceptionOccurred()); + return; + } + } +} + +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 = (jmePhysicsSpace *)up0->space; + if (dynamicsWorld != NULL) { + JNIEnv* env = dynamicsWorld->getEnv(); + jobject javaPhysicsSpace = env->NewLocalRef(dynamicsWorld->getJavaPhysicsSpace()); + if (javaPhysicsSpace != NULL) { + jobject javaCollisionObject0 = env->NewLocalRef(up0->javaCollisionObject); + jobject javaCollisionObject1 = env->NewLocalRef(up1->javaCollisionObject); + env->CallVoidMethod(javaPhysicsSpace, jmeClasses::PhysicsSpace_addCollisionEvent, javaCollisionObject0, javaCollisionObject1, (jlong) & cp); + env->DeleteLocalRef(javaPhysicsSpace); + env->DeleteLocalRef(javaCollisionObject0); + env->DeleteLocalRef(javaCollisionObject1); + if (env->ExceptionCheck()) { + env->Throw(env->ExceptionOccurred()); + return true; + } + } + } + } + return true; +} + +btDynamicsWorld* jmePhysicsSpace::getDynamicsWorld() { + return dynamicsWorld; +} + +jobject jmePhysicsSpace::getJavaPhysicsSpace() { + return javaPhysicsSpace; +} + +jmePhysicsSpace::~jmePhysicsSpace() { + delete(dynamicsWorld); +}
\ No newline at end of file |