Show DopeEntidad.h syntax highlighted
#ifndef __DOPE_ENTIDAD_H__
#define __DOPE_ENTIDAD_H__
#include "DopePrerequisites.h"
namespace Dope {
class Entidad : public UserDefinedObject
{
protected:
// Visual component
SceneNode* mSceneNode;
Entity* mEntity;
/// Dynamics properties, must be set up by subclasses if dynamics enabled
dBody* mOdeBody;
/// Mass parameters
dMass mMass;
/// Collision proxies, must be set up if collision enabled
typedef std::list<dGeom*> CollisionProxyList;
CollisionProxyList mCollisionProxies;
bool mDynamicsEnabled;
bool mReenableIfInteractedWith;
bool mCollisionEnabled;
Real mBounceCoeffRestitution;
Real mBounceVelocityThreshold;
Real mSoftness;
Real mFriction;
Real mLinearVelDisableThreshold;
Real mAngularVelDisableThreshold;
Real mDisableTime;
Real mDisableTimeEnd;
// Set up method, must override
virtual void setUp(const String& name) = 0;
/** Internal method for updating the state of the collision proxies. */
virtual void updateCollisionProxies(void);
/** Internal method for testing the plane bounded region WorldFragment type. */
virtual bool testCollidePlaneBounds(SceneQuery::WorldFragment* wf);
/// Internal method for updating the query mask
virtual void setEntityQueryFlags(void);
public:
Entidad(const String& name);
virtual ~Entidad();
/** Sets the position of this object. */
virtual void setPosition(const Vector3& vec);
/** Sets the position of this object. */
virtual void setPosition(Real x, Real y, Real z);
/** Sets the orientation of this object. */
virtual void setOrientation(const Quaternion& orientation);
/** Gets the current position of this object. */
virtual const Vector3& getPosition(void);
/** Gets the current orientation of this object. */
virtual const Quaternion& getOrientation(void);
/// Updates the position of this game object from the simulation
virtual void _updateFromDynamics(void);
/// Returns whether or not this object is considered for collision.
virtual bool isCollisionEnabled(void);
/** Returns whether or not this object is physically simulated.
@remarks
Objects which are not physically simulated only move when their
SceneNode is manually altered.
*/
virtual bool isDynamicsEnabled(void);
/** Sets whether or not this object is considered for collision.
@remarks
Objects which have collision enabled must set up an ODE
collision proxy as part of their setUp method.
*/
/** Sets the linear and angular velocity thresholds, below which the
object will have it's dynamics automatically disabled for performance.
@remarks
These thresholds are used to speed up the simulation and to make it more
stable, by turning off dynamics for objects that appear to be at rest.
Otherwise, objects which are supposedly stationary can jitter when involved
in large stacks, and can consume unnecessary CPU time. Note that if another
object interacts with the disabled object, it will automatically reenable itself.
@par
If you never want to disable dynamics automatically for this object, just
set all the values to 0.
@param linearSq The squared linear velocity magnitude threshold
@param angularSq The squared angular velocity magnitude threshold
@param overTime The number of seconds over which the values must continue to be under
this threshold for the dynamics to be disabled. This is to catch cases
where the object almost stops moving because of a boundary condition, but
would speed up again later (e.g. box teetering on an edge).
*/
virtual void setDynamicsDisableThreshold(Real linearSq, Real angularSq, Real overTime);
virtual void setCollisionEnabled(bool enabled);
/** Sets whether or not this object is physically simulated at this time.
@remarks
Objects which are not physically simulated only move when their
SceneNode is manually altered. Objects which are physically
simulated must set up an ODE body as part of their setUp method.
@par
You can also use this to temporarily turn off simulation on an object,
such that it is not simulated until some other object which IS simulated
comes in contact with it, or is attached to it with a joint.
@param enabled Specifies whether dynamics is enabled
@param reEnableOnInteraction If set to true, this object will reenable if some
other dynamically simulated object interacts with it
*/
virtual void setDynamicsEnabled(bool enabled, bool reEnableOnInteraction = false);
/** Sets the 'bounciness' of this object.
* @remarks
* Only applies if this object has both collision and dynamics enabled.
* When 2 movable objects collide, the greatest bounce parameters
* from both objects apply, so even a non-bouncy object can
* bounce if it hits a bouncy surface.
* @param restitutionValue Coeeficient of restitution
* (0 for no bounce, 1 for perfect bounciness)
* @param velocityThreshold Velocity below which no bounce will occur;
* this is a dampening value to ensure small velocities do not
* cause bounce.
*/
virtual void setBounceParameters(Real restitutionValue, Real velocityThreshold);
/** Gets the cefficient of restitution (bounciness) for this object. */
virtual Real getBounceRestitutionValue(void);
/** Gets the bounce velocity threshold for this object. */
virtual Real getBounceVelocityThreshold(void);
/** Sets the softness of this object, which determines how much it is allowed to
* penetrate other objects.
* @remarks
* This parameter only has meaning if collision and dynamics are enabled for this object.
* @param softness Softness factor (0 is completely hard). Softness will be combined from
* both objects involved in a collision to determine how much they will penetrate.
*/
virtual void setSoftness(Real softness);
/** Gets the softness factor of this object. */
virtual Real getSoftness(void);
/** Sets the Coulomb frictional coefficient for this object.
@remarks
This coefficient affects how much an object will slip when it comes
into contact with another object.
@param friction The Coulomb friction coefficient, valid from 0 to Math::POS_INFINITY.
0 means no friction, Math::POS_INFINITY means infinite friction ie no slippage.
Note that friction between these 2 bounds is more CPU intensive so use with caution.
*/
virtual void setFriction(Real friction);
/** Gets the Coulomb frictional coefficient for this object. */
virtual Real getFriction(void);
/** Adds a linear force to this object, in object space, at the position indicated.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param direction The force direction in object coordinates.
@param atPosition The position at which the force is to be applied, in object coordinates.
*/
virtual void addForce(const Vector3& direction, const Vector3& atPosition = Vector3::ZERO);
/** Adds a linear force to this object, in object space, at the position indicated.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param dir_x, dir_y, dir_z The force direction in object coordinates.
@param pos_x, pos_y, pos_z The position at which the force is to be applied, in object coordinates.
*/
virtual void addForce(Real dir_x, Real dir_y, Real dir_z,
Real pos_x = 0, Real pos_y = 0, Real pos_z = 0);
/** Adds a linear force to this object, in world space, at the position indicated.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param direction The force direction in world coordinates.
@param atPosition The position at which the force is to be applied, in world coordinates.
*/
virtual void addForceWorldSpace(const Vector3& direction, const Vector3& atPosition = Vector3::ZERO);
/** Adds a linear force to this object, in world space, at the position indicated.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param dir_x, dir_y, dir_z The force direction in world coordinates.
@param pos_x, pos_y, pos_z The position at which the force is to be applied, in world coordinates.
*/
virtual void addForceWorldSpace(Real dir_x, Real dir_y, Real dir_z,
Real pos_x, Real pos_y, Real pos_z);
/** Adds rotational force to this object, in object space.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param direction The direction of the torque to apply, in object space. */
virtual void addTorque(const Vector3& direction);
/** Adds rotational force to this object, in object space.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param x, y, z The direction of the torque to apply, in object space. */
virtual void addTorque(Real x, Real y, Real z);
/** Adds rotational force to this object, in world space.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param direction The direction of the torque to apply, in world space. */
virtual void addTorqueWorldSpace(const Vector3& direction);
/** Adds rotational force to this object, in world space.
@remarks
All forces are applied, then reset after World::applyDynamics is called.
@param x, y, z The direction of the torque to apply, in world space. */
virtual void addTorqueWorldSpace(Real x, Real y, Real z);
/** Tests to see if there is a detailed collision between this object and the object passed in.
@remarks
If there is a collision, both objects will be notified and if dynamics are enabled
on these objects, physics will be applied automatically.
@returns true if collision occurred
*/
virtual bool testCollide(Entidad* otherObj);
/** Tests to see if there is a detailed collision between this object and the
world fragment passed in.
@remarks
If there is a collision, the object will be notified and if dynamics are enabled
on this object, physics will be applied automatically.
@returns true if collision occurred
*/
virtual bool testCollide(SceneQuery::WorldFragment* wf);
/** Contains information about a collision; used in the _notifyCollided call. */
struct CollisionInfo
{
/// The position in world coordinates at which the collision occurred
Vector3 position;
/// The normal in world coordinates of the collision surface
Vector3 normal;
/// Penetration depth
Real penetrationDepth;
};
/** This method is called automatically if testCollide indicates a real collision.
*/
virtual void _notifyCollided(Entidad* otherObj, const CollisionInfo& info);
/** This method is called automatically if testCollide indicates a real collision.
*/
virtual void _notifyCollided(SceneQuery::WorldFragment* wf, const CollisionInfo& info);
/** Gets the SceneNode which is being used to represent this object's position in
the OGRE world. */
SceneNode* getSceneNode(void);
/** Gets the Entity which is being used to represent this object in the OGRE world. */
Entity* getEntity(void);
/** Gets the ODE body used to represent this object's mass and current velocity. */
dBody* getOdeBody(void);
/** Set the mass parameters of this object to represent a sphere.
@remarks
This method sets the mass and inertia properties of this object such
that it is like a sphere, ie center of gravity at the origin and
an even distribution of mass in all directions.
@param density Density of the sphere in Kg/m^3
@param radius of the sphere mass
*/
void setMassSphere(Real density, Real radius);
/** Set the mass parameters of this object to represent a box.
@remarks
This method sets the mass and inertia properties of this object such
that it is like a box.
@param density Density of the box in Kg/m^3
@param dimensions Width, height and depth of the box.
@param orientation Optional orientation of the box.
*/
void setMassBox(Real density, const Vector3& dimensions,
const Quaternion& orientation = Quaternion::IDENTITY);
/** Set the mass parameters of this object to represent a capped cylinder.
@remarks
This method sets the mass and inertia properties of this object such
that it is like a capped cylinder, by default lying along the Z-axis.
@param density Density of the cylinder in Kg/m^3
@param length Length of the cylinder
@param width Width of the cylinder
@param orientation Optional orientation if you wish the cylinder to lay
along a different axis from Z.
*/
void setMassCappedCylinder(Real density, Real length, Real width,
const Quaternion& orientation = Quaternion::IDENTITY);
/** Sets the mass parameters manually, use only if you know how!
@param mass Mass in Kg
@param center The center of gravity
@param inertia The inertia matrix describing distribution of the mass around the body.
*/
void setMassExpert(Real mass, const Vector3 center, const Matrix3 inertia);
/** Gets the ODE mass parameters for this object. */
const dMass* getOdeMass(void);
/** Sets the current linear velocity of this object.
@remarks
Only applicable if dynamics are enabled for this object. This method is useful
for starting an object off at a particular speed rather than applying forces to get
it there.
*/
void setLinearVelocity(const Vector3& vel);
/** Sets the current linear velocity of this object.
@remarks
Only applicable if dynamics are enabled for this object. This method is useful
for starting an object off at a particular speed rather than applying forces to get
it there.
*/
void setLinearVelocity(Real x, Real y, Real z);
/** Gets the current linear velocity of this object.
@remarks
Only applicable if dynamics are enabled for this object.
@returns Vector3 representing the velocity in units per second.
*/
const Vector3& getLinearVelocity(void);
/** Gets the current angular velocity of this object.
@remarks
Only applicable if dynamics are enabled for this object.
@returns Vector3 representing the angular velocity in units per second around each axis.
*/
const Vector3& getAngularVelocity(void);
/** Sets the current angular velocity of this object.
@remarks
Only applicable if dynamics are enabled for this object. This method is useful
for starting an object off rather than applying forces to get
it there.
*/
void setAngularVelocity(const Vector3& vel);
/** Sets the current angular velocity of this object.
@remarks
Only applicable if dynamics are enabled for this object. This method is useful
for starting an object off rather than applying forces to get
it there.
*/
void setAngularVelocity(Real x, Real y, Real z);
/** Moves the object along it's local axes.
@par
This method moves the object by the supplied vector along the
local axes of the obect.
@param
d Vector with x,y,z values representing the translation.
*/
virtual void translate(const Vector3& d);
/** Moves the object along it's local axes.
@par
This method moves the object by the supplied vector along the
local axes of the obect.
@param x, y z Real x, y and z values representing the translation.
*/
virtual void translate(Real x, Real y, Real z);
/** Moves the object along the world axes.
@par
This method moves the object by the supplied vector along the
world axes.
@param
d Vector with x,y,z values representing the translation.
*/
virtual void translateWorldSpace(const Vector3& d);
/** Moves the object along the world axes.
@par
This method moves the object by the supplied vector along the
local axes of the obect.
@param x, y z Real x, y and z values representing the translation.
*/
virtual void translateWorldSpace(Real x, Real y, Real z);
/** Rotate the object around the local Z-axis.
*/
virtual void roll(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
inline void roll(Real angleunits) {
roll ( Angle(angleunits) );
}
#endif//OGRE_FORCE_ANGLE_TYPES
/** Rotate the object around the local X-axis.
*/
virtual void pitch(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
inline void pitch(Real angleunits) {
pitch ( Angle(angleunits) );
}
#endif//OGRE_FORCE_ANGLE_TYPES
/** Rotate the object around the local Y-axis.
*/
virtual void yaw(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
inline void yaw(Real angleunits) {
yaw ( Angle(angleunits) );
}
#endif//OGRE_FORCE_ANGLE_TYPES
/** Rotate the object around an arbitrary axis.
*/
virtual void rotate(const Vector3& axis, const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
inline void rotate(const Vector3& axis, Real angleunits) {
rotate ( axis, Angle(angleunits) );
}
#endif//OGRE_FORCE_ANGLE_TYPES
/** Rotate the object around an aritrary axis using a Quarternion.
*/
virtual void rotate(const Quaternion& q);
};
} // namespace
#endif
See more files for this project here