com.bulletphysics.collision.dispatch.CollisionObject Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jbullet Show documentation
JBullet - Java port of Bullet Physics Library
The newest version!
/*
 * Java port of Bullet (c) 2008 Martin Dvorak 
 *
 * 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 {
	
	//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;
	protected 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;
	}
}