/*
|
* Java port of Bullet (c) 2008 Martin Dvorak <jezek2@advel.cz>
|
*
|
* Bullet Continuous Collision Detection and Physics Library
|
* Copyright (c) 2003-2008 Erwin Coumans http://www.bulletphysics.com/
|
*
|
* This software is provided 'as-is', without any express or implied warranty.
|
* In no event will the authors be held liable for any damages arising from
|
* the use of this software.
|
*
|
* Permission is granted to anyone to use this software for any purpose,
|
* including commercial applications, and to alter it and redistribute it
|
* freely, subject to the following restrictions:
|
*
|
* 1. The origin of this software must not be misrepresented; you must not
|
* claim that you wrote the original software. If you use this software
|
* in a product, an acknowledgment in the product documentation would be
|
* appreciated but is not required.
|
* 2. Altered source versions must be plainly marked as such, and must not be
|
* misrepresented as being the original software.
|
* 3. This notice may not be removed or altered from any source distribution.
|
*/
|
|
package com.bulletphysics.collision.dispatch;
|
|
import com.bulletphysics.collision.broadphase.BroadphaseProxy;
|
import com.bulletphysics.collision.shapes.CollisionShape;
|
import com.bulletphysics.linearmath.Transform;
|
import javax.vecmath.Vector3f;
|
|
/**
|
* CollisionObject can be used to manage collision detection objects.
|
* It maintains all information that is needed for a collision detection: {@link CollisionShape},
|
* {@link Transform} and {@link BroadphaseProxy AABB proxy}. It can be added to {@link CollisionWorld}.
|
*
|
* @author jezek2
|
*/
|
public class CollisionObject implements java.io.Serializable
|
{
|
static final long serialVersionUID = -12104200275953859L;
|
|
//protected final BulletStack stack = BulletStack.get();
|
|
// island management, m_activationState1
|
public static final int ACTIVE_TAG = 1;
|
public static final int ISLAND_SLEEPING = 2;
|
public static final int WANTS_DEACTIVATION = 3;
|
public static final int DISABLE_DEACTIVATION = 4;
|
public static final int DISABLE_SIMULATION = 5;
|
public Transform worldTransform = new Transform();
|
|
///m_interpolationWorldTransform is used for CCD and interpolation
|
///it can be either previous or future (predicted) transform
|
protected final Transform interpolationWorldTransform = new Transform();
|
//those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities)
|
//without destroying the continuous interpolated motion (which uses this interpolation velocities)
|
protected final Vector3f interpolationLinearVelocity = new Vector3f();
|
protected final Vector3f interpolationAngularVelocity = new Vector3f();
|
protected BroadphaseProxy broadphaseHandle;
|
protected CollisionShape collisionShape;
|
|
// rootCollisionShape is temporarily used to store the original collision shape
|
// The collisionShape might be temporarily replaced by a child collision shape during collision detection purposes
|
// If it is null, the collisionShape is not temporarily replaced.
|
protected CollisionShape rootCollisionShape;
|
|
protected int collisionFlags;
|
protected int islandTag1;
|
protected int companionId;
|
protected int activationState1;
|
protected float deactivationTime;
|
protected float friction;
|
protected float restitution;
|
|
///users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer
|
protected Object userObjectPointer;
|
|
// internalType is reserved to distinguish Bullet's CollisionObject, RigidBody, SoftBody etc.
|
// do not assign your own internalType unless you write a new dynamics object class.
|
protected CollisionObjectType internalType = CollisionObjectType.COLLISION_OBJECT;
|
|
///time of impact calculation
|
protected float hitFraction;
|
///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
|
protected float ccdSweptSphereRadius;
|
|
/// Don't do continuous collision detection if the motion (in one step) is less then ccdMotionThreshold
|
protected float ccdMotionThreshold = 0f;
|
/// If some object should have elaborate collision filtering by sub-classes
|
protected boolean checkCollideWith;
|
|
public CollisionObject() {
|
this.collisionFlags = CollisionFlags.STATIC_OBJECT;
|
this.islandTag1 = -1;
|
this.companionId = -1;
|
this.activationState1 = 1;
|
this.friction = 0.5f;
|
this.hitFraction = 1f;
|
}
|
|
public boolean checkCollideWithOverride(CollisionObject co) {
|
return true;
|
}
|
|
public boolean mergesSimulationIslands() {
|
///static objects, kinematic and object without contact response don't merge islands
|
return ((collisionFlags & (CollisionFlags.STATIC_OBJECT | CollisionFlags.KINEMATIC_OBJECT | CollisionFlags.NO_CONTACT_RESPONSE)) == 0);
|
}
|
|
public boolean isStaticObject() {
|
return (collisionFlags & CollisionFlags.STATIC_OBJECT) != 0;
|
}
|
|
public boolean isKinematicObject() {
|
return (collisionFlags & CollisionFlags.KINEMATIC_OBJECT) != 0;
|
}
|
|
public boolean isStaticOrKinematicObject() {
|
return (collisionFlags & (CollisionFlags.KINEMATIC_OBJECT | CollisionFlags.STATIC_OBJECT)) != 0;
|
}
|
|
public boolean hasContactResponse() {
|
return (collisionFlags & CollisionFlags.NO_CONTACT_RESPONSE) == 0;
|
}
|
|
public CollisionShape getCollisionShape() {
|
return collisionShape;
|
}
|
|
public void setCollisionShape(CollisionShape collisionShape) {
|
this.collisionShape = collisionShape;
|
this.rootCollisionShape = collisionShape;
|
}
|
|
public CollisionShape getRootCollisionShape() {
|
return rootCollisionShape;
|
}
|
|
/**
|
* Avoid using this internal API call.
|
* internalSetTemporaryCollisionShape is used to temporary replace the actual collision shape by a child collision shape.
|
*/
|
public void internalSetTemporaryCollisionShape(CollisionShape collisionShape) {
|
this.collisionShape = collisionShape;
|
}
|
|
public int getActivationState() {
|
return activationState1;
|
}
|
|
public void setActivationState(int newState) {
|
if ((activationState1 != DISABLE_DEACTIVATION) && (activationState1 != DISABLE_SIMULATION)) {
|
this.activationState1 = newState;
|
}
|
}
|
|
public float getDeactivationTime() {
|
return deactivationTime;
|
}
|
|
public void setDeactivationTime(float deactivationTime) {
|
this.deactivationTime = deactivationTime;
|
}
|
|
public void forceActivationState(int newState) {
|
this.activationState1 = newState;
|
}
|
|
public void activate() {
|
activate(false);
|
}
|
|
public void activate(boolean forceActivation) {
|
if (forceActivation || (collisionFlags & (CollisionFlags.STATIC_OBJECT | CollisionFlags.KINEMATIC_OBJECT)) == 0) {
|
setActivationState(ACTIVE_TAG);
|
deactivationTime = 0f;
|
}
|
}
|
|
public boolean isActive() {
|
return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
|
}
|
|
public float getRestitution() {
|
return restitution;
|
}
|
|
public void setRestitution(float restitution) {
|
this.restitution = restitution;
|
}
|
|
public float getFriction() {
|
return friction;
|
}
|
|
public void setFriction(float friction) {
|
this.friction = friction;
|
}
|
|
// reserved for Bullet internal usage
|
public CollisionObjectType getInternalType() {
|
return internalType;
|
}
|
|
public Transform getWorldTransform(Transform out) {
|
out.set(worldTransform);
|
return out;
|
}
|
|
public void setWorldTransform(Transform worldTransform) {
|
this.worldTransform.set(worldTransform);
|
}
|
|
public BroadphaseProxy getBroadphaseHandle() {
|
return broadphaseHandle;
|
}
|
|
public void setBroadphaseHandle(BroadphaseProxy broadphaseHandle) {
|
this.broadphaseHandle = broadphaseHandle;
|
}
|
|
public Transform getInterpolationWorldTransform(Transform out) {
|
out.set(interpolationWorldTransform);
|
return out;
|
}
|
|
public void setInterpolationWorldTransform(Transform interpolationWorldTransform) {
|
this.interpolationWorldTransform.set(interpolationWorldTransform);
|
}
|
|
public void setInterpolationLinearVelocity(Vector3f linvel) {
|
interpolationLinearVelocity.set(linvel);
|
}
|
|
public void setInterpolationAngularVelocity(Vector3f angvel) {
|
interpolationAngularVelocity.set(angvel);
|
}
|
|
public Vector3f getInterpolationLinearVelocity(Vector3f out) {
|
out.set(interpolationLinearVelocity);
|
return out;
|
}
|
|
public Vector3f getInterpolationAngularVelocity(Vector3f out) {
|
out.set(interpolationAngularVelocity);
|
return out;
|
}
|
|
public int getIslandTag() {
|
return islandTag1;
|
}
|
|
public void setIslandTag(int islandTag) {
|
this.islandTag1 = islandTag;
|
}
|
|
public int getCompanionId() {
|
return companionId;
|
}
|
|
public void setCompanionId(int companionId) {
|
this.companionId = companionId;
|
}
|
|
public float getHitFraction() {
|
return hitFraction;
|
}
|
|
public void setHitFraction(float hitFraction) {
|
this.hitFraction = hitFraction;
|
}
|
|
public int getCollisionFlags() {
|
return collisionFlags;
|
}
|
|
public void setCollisionFlags(int collisionFlags) {
|
this.collisionFlags = collisionFlags;
|
}
|
|
// Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
|
public float getCcdSweptSphereRadius() {
|
return ccdSweptSphereRadius;
|
}
|
|
// Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
|
public void setCcdSweptSphereRadius(float ccdSweptSphereRadius) {
|
this.ccdSweptSphereRadius = ccdSweptSphereRadius;
|
}
|
|
public float getCcdMotionThreshold() {
|
return ccdMotionThreshold;
|
}
|
|
public float getCcdSquareMotionThreshold() {
|
return ccdMotionThreshold * ccdMotionThreshold;
|
}
|
|
// Don't do continuous collision detection if the motion (in one step) is less then ccdMotionThreshold
|
public void setCcdMotionThreshold(float ccdMotionThreshold) {
|
// JAVA NOTE: fixed bug with usage of ccdMotionThreshold*ccdMotionThreshold
|
this.ccdMotionThreshold = ccdMotionThreshold;
|
}
|
|
public Object getUserPointer() {
|
return userObjectPointer;
|
}
|
|
public void setUserPointer(Object userObjectPointer) {
|
this.userObjectPointer = userObjectPointer;
|
}
|
|
public boolean checkCollideWith(CollisionObject co) {
|
if (checkCollideWith) {
|
return checkCollideWithOverride(co);
|
}
|
|
return true;
|
}
|
}
|
