Abstract PL physics world (also called 'simulator') base class. More...

#include <World.h>

Inheritance diagram for PLPhysics::World:

Public Types
enum	EBodyPairFlags { Ignore = 1<<0 }
	Body pair flags. More...
Public Member Functions
	pl_class (PLPHYSICS_RTTI_EXPORT, World,"PLPhysics", PLCore::Object,"Abstract PL physics world (also called 'simulator') base class") pl_signal_1(SignalContact
virtual PLPHYSICS_API	~World ()
	Destructor.
virtual Body *	CreateBodyBox (const PLMath::Vector3 &vDimension, bool bStatic=false)=0
	Creates a physics box body.
virtual Body *	CreateBodySphere (float fRadius, bool bStatic=false)=0
	Creates a physics sphere body.
virtual Body *	CreateBodyEllipsoid (const PLMath::Vector3 &vRadius, bool bStatic=false)=0
	Creates a physics ellipsoid body.
virtual Body *	CreateBodyConvexHull (PLMesh::MeshManager &cMeshManager, const PLCore::String &sMesh, const PLMath::Vector3 &vMeshScale=PLMath::Vector3::One, bool bStatic=false)=0
	Creates a physics convex hull body.
virtual Body *	CreateBodyMesh (PLMesh::MeshManager &cMeshManager, const PLCore::String &sMesh, const PLMath::Vector3 &vMeshScale=PLMath::Vector3::One, bool bOptimize=false)=0
	Creates a physics mesh body.
virtual Body *	CreateBodyTerrain (PLCore::uint32 nWidth, PLCore::uint32 nHeight, const float fTerrain[], const PLMath::Vector3 &vBoxMin, const PLMath::Vector3 &vBoxMax, const PLMath::Vector3 &vScale)=0
	Creates a physics terrain body.
virtual Body *	CreateBodyCylinder (float fRadius, float fHeight, bool bStatic=false)=0
	Creates a physics cylinder body.
virtual Body *	CreateBodyCone (float fRadius, float fHeight, bool bStatic=false)=0
	Creates a physics cone body.
virtual Body *	CreateBodyCapsule (float fRadius, float fHeight, bool bStatic=false)=0
	Creates a physics capsule body.
virtual Body *	CreateBodyChamferCylinder (float fRadius, float fHeight, bool bStatic=false)=0
	Creates a physics chamfer cylinder body.
virtual Joint *	CreateJointBall (Body pParentBody, Body pChildBody, const PLMath::Vector3 &vPivotPoint, const PLMath::Vector3 &vPinDir)=0
	Creates a physics ball and socket joint.
virtual Joint *	CreateJointSlider (Body pParentBody, Body pChildBody, const PLMath::Vector3 &vPivotPoint, const PLMath::Vector3 &vPinDir)=0
	Creates a physics slider joint.
virtual Joint *	CreateJointHinge (Body pParentBody, Body pChildBody, const PLMath::Vector3 &vPivotPoint, const PLMath::Vector3 &vPinDir)=0
	Creates a physics hinge joint.
virtual Joint *	CreateJointUniversal (Body pParentBody, Body pChildBody, const PLMath::Vector3 &vPivotPoint, const PLMath::Vector3 &vPinDir1, const PLMath::Vector3 &vPinDir2)=0
	Creates a physics universal joint.
virtual Joint *	CreateJointCorkscrew (Body pParentBody, Body pChildBody, const PLMath::Vector3 &vPivotPoint, const PLMath::Vector3 &vPinDir)=0
	Creates a physics corkscrew joint.
virtual Joint *	CreateJointUpVector (Body &cParentBody, const PLMath::Vector3 &vPinDir)=0
	Creates a physics up vector joint.
virtual Sensor *	CreateSensorRaycast (const PLMath::Vector3 &vStart=PLMath::Vector3::Zero, const PLMath::Vector3 &vEnd=PLMath::Vector3::Zero, PLCore::uint32 nFlags=0)=0
	Creates a physics ray cast sensor.
virtual Sensor *	CreateSensorAABoundingBox (const PLMath::Vector3 &vMin=PLMath::Vector3::Zero, const PLMath::Vector3 &vMax=PLMath::Vector3::Zero, PLCore::uint32 nFlags=0)=0
	Creates a physics axis aligned bounding box sensor.
virtual void	GetWorldSize (PLMath::Vector3 &vMin, PLMath::Vector3 &vMax) const =0
	Returns the world size.
virtual void	SetWorldSize (const PLMath::Vector3 &vMin=PLMath::Vector3(-10000.0f,-10000.0f,-10000.0f), const PLMath::Vector3 &vMax=PLMath::Vector3(10000.0f, 10000.0f, 10000.0f))=0
	Sets the world size.
virtual bool	IsSimulationActive () const =0
	Returns whether the simulation is currently active or not.
virtual void	SetSimulationActive (bool bActive=true)=0
	Sets whether the simulation is currently active or not.
virtual float	GetSimulationSpeed () const =0
	Returns the simulation speed.
virtual bool	SetSimulationSpeed (float fSpeed=1.0f)=0
	Sets the simulation speed.
virtual float	GetSimulationQuality () const =0
	Returns the simulation quality.
virtual bool	SetSimulationQuality (float fQuality=1.0f)=0
	Sets the simulation quality.
virtual float	GetFrameRate () const =0
	Returns the frame rate the simulation runs on.
virtual bool	SetFrameRate (float fFrameRate=60.0f)=0
	Sets the frame rate the simulation runs on.
virtual void	GetGravity (PLMath::Vector3 &vGravity) const =0
	Returns the gravity vector.
virtual void	SetGravity (const PLMath::Vector3 &vGravity=PLMath::Vector3(0.0f,-9.81f, 0.0f))=0
	Sets the gravity vector.
virtual bool	GetGroupCollision (PLCore::uint8 nGroup1, PLCore::uint8 nGroup2) const =0
	Returns whether collision is active between the two given collision groups or not.
virtual void	SetGroupCollision (PLCore::uint8 nGroup1, PLCore::uint8 nGroup2, bool bActive=true)=0
	Sets whether collision is active between the two given collision groups or not.
virtual PLCore::uint8	GetBodyPairFlags (const Body &cBody1, const Body &cBody2) const =0
	Returns body pair flags.
virtual void	SetBodyPairFlags (const Body &cBody1, const Body &cBody2, PLCore::uint8 nFlags=0)=0
	Sets the body pair flags.
virtual bool	IsBuoyancyActive () const =0
	Returns whether buoyancy force is used.
virtual void	SetBuoyancyActive (bool bActive=false)=0
	Sets whether buoyancy force is used.
virtual float	GetBuoyancyPlaneY () const =0
	Returns the y position of the buoyancy plane.
virtual void	SetBuoyancyPlaneY (float fY=0.0f)=0
	Sets the y position of the buoyancy plane.
virtual void	UpdateSimulation ()=0
	Updates the simulation.
virtual bool	IsAlwaysStatic () const =0
	Returns whether the bodies are always static or not.
Public Attributes
ContactInformation A contact between two bodies was detected by the physics Contact information as	parameter
Protected Member Functions
PLPHYSICS_API	World ()
	Constructor.

Detailed Description

Abstract PL physics world (also called 'simulator') base class.

Remarks:: Because it's possible that the physics runs in an own thread, it's recommended to deactivate the simulation by using SetSimulationActive(false) during scene creation. Note that the behavior of the functions may differ a bit between the different physics implementations. For instance, some physics implementations will ignore completely the linear velocity if the body is static. In general you can't expect the same values as the ones set by yourself. For instance Body::GetLinearVelocity() must not be vMyVelocity you set using Body::SetLinearVelocity(vMyVelocity)!

Member Enumeration Documentation

enum PLPhysics::World::EBodyPairFlags

Body pair flags.

Enumerator:

Ignore

Do NOT create contacts for this pair

Constructor & Destructor Documentation

virtual PLPHYSICS_API PLPhysics::World::~World ( ) [virtual]

Destructor.

PLPHYSICS_API PLPhysics::World::World ( ) [protected]

Constructor.

Member Function Documentation

PLPhysics::World::pl_class	(	PLPHYSICS_RTTI_EXPORT	,
		World	,
		"PLPhysics"	,
		PLCore::Object	,
		"Abstract PL physics world (also called 'simulator') base class"
	)

virtual Body* PLPhysics::World::CreateBodyBox	(	const PLMath::Vector3 &	vDimension,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics box body.

Parameters:

[in]	vDimension	Box dimension
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Body* PLPhysics::World::CreateBodySphere	(	float	fRadius,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics sphere body.

Parameters:

[in]	fRadius	Sphere radius
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Body* PLPhysics::World::CreateBodyEllipsoid	(	const PLMath::Vector3 &	vRadius,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics ellipsoid body.

Parameters:

[in]	vRadius	Ellipsoid radius along each axis
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Body* PLPhysics::World::CreateBodyConvexHull	(	PLMesh::MeshManager &	cMeshManager,
		const PLCore::String &	sMesh,
		const PLMath::Vector3 &	vMeshScale = `PLMath::Vector3::One`,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics convex hull body.

Parameters:

[in]	cMeshManager	Mesh manager to use
[in]	sMesh	Collision mesh
[in]	vMeshScale	Mesh scale
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported? invalid mesh?)

Remarks:: The physics implementation is free to don't use the mesh at all. For example if no support or when using 'cached data'. Therefore this function is using a mesh manager and mesh name instead of a direct mesh instance to just load/use the mesh 'on demand'.

virtual Body* PLPhysics::World::CreateBodyMesh	(	PLMesh::MeshManager &	cMeshManager,
		const PLCore::String &	sMesh,
		const PLMath::Vector3 &	vMeshScale = `PLMath::Vector3::One`,
		bool	bOptimize = `false`
	)		`[pure virtual]`

Creates a physics mesh body.

Parameters:

[in]	cMeshManager	Mesh manager to use
[in]	sMesh	Collision mesh
[in]	vMeshScale	Mesh scale
[in]	bOptimize	Allow the physics API to optimize the mesh? (if supported)

Returns:: The created physics body, a null pointer on error (body type not supported? invalid mesh?)

Remarks:: The physics implementation is free to don't use the mesh at all. For example if no support or when using 'cached data'. Therefore this function is using a mesh manager and mesh name instead of a direct mesh instance to just load/use the mesh 'on demand'.

virtual Body* PLPhysics::World::CreateBodyTerrain	(	PLCore::uint32	nWidth,
		PLCore::uint32	nHeight,
		const float	fTerrain[],
		const PLMath::Vector3 &	vBoxMin,
		const PLMath::Vector3 &	vBoxMax,
		const PLMath::Vector3 &	vScale
	)		`[pure virtual]`

Creates a physics terrain body.

Parameters:

[in]	nWidth	Terrain data width
[in]	nHeight	Terrain data height
[in]	fTerrain	Terrain data
[in]	vBoxMin	Bounding box minimum
[in]	vBoxMax	Bounding box maximum
[in]	vScale	Scale

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Body* PLPhysics::World::CreateBodyCylinder	(	float	fRadius,
		float	fHeight,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics cylinder body.

Parameters:

[in]	fRadius	Cylinder radius at the base
[in]	fHeight	Cylinder height along the x local axis from base to top
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Body* PLPhysics::World::CreateBodyCone	(	float	fRadius,
		float	fHeight,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics cone body.

Parameters:

[in]	fRadius	Cone radius at the base
[in]	fHeight	Cone height along the x local axis from base to top
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Body* PLPhysics::World::CreateBodyCapsule	(	float	fRadius,
		float	fHeight,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics capsule body.

Parameters:

[in]	fRadius	Capsule radius at the base
[in]	fHeight	Capsule height along the x local axis from base to top
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Body* PLPhysics::World::CreateBodyChamferCylinder	(	float	fRadius,
		float	fHeight,
		bool	bStatic = `false`
	)		`[pure virtual]`

Creates a physics chamfer cylinder body.

Parameters:

[in]	fRadius	Chamfer cylinder radius at the base
[in]	fHeight	Chamfer cylinder height along the x local axis from base to top
[in]	bStatic	Is this physics body static?

Returns:: The created physics body, a null pointer on error (body type not supported?)

virtual Joint* PLPhysics::World::CreateJointBall	(	Body *	pParentBody,
		Body *	pChildBody,
		const PLMath::Vector3 &	vPivotPoint,
		const PLMath::Vector3 &	vPinDir
	)		`[pure virtual]`

Creates a physics ball and socket joint.

Parameters:

[in]	pParentBody	Pointer to the parent rigid body, can be a null pointer
[in]	pChildBody	Pointer to the attached rigid body, can be a null pointer
[in]	vPivotPoint	Origin of the ball and socket in world space
[in]	vPinDir	Vector defining the cone axis in world space

Returns:: The created physics joint, a null pointer on error (joint type not supported?)

Note:

If 'pParentBody' or 'pChildBody' is a null pointer, the joint is attached to the world (static joint)
ONLY 'pParentBody' OR 'pChildBody' can be a null pointer, if both are a null pointer this function will return a null pointer
If 'pParentBody' is the same as 'pChildBody' this function will return a null pointer

virtual Joint* PLPhysics::World::CreateJointSlider	(	Body *	pParentBody,
		Body *	pChildBody,
		const PLMath::Vector3 &	vPivotPoint,
		const PLMath::Vector3 &	vPinDir
	)		`[pure virtual]`

Creates a physics slider joint.

Parameters:

[in]	pParentBody	Pointer to the parent rigid body, can be a null pointer
[in]	pChildBody	Pointer to the attached rigid body, can be a null pointer
[in]	vPivotPoint	Origin of the slider in world space
[in]	vPinDir	The line of action of the slider in world space

Returns:: The created physics joint, a null pointer on error (joint type not supported?)

See also:

CreateJointBall()

virtual Joint* PLPhysics::World::CreateJointHinge	(	Body *	pParentBody,
		Body *	pChildBody,
		const PLMath::Vector3 &	vPivotPoint,
		const PLMath::Vector3 &	vPinDir
	)		`[pure virtual]`

Creates a physics hinge joint.

Parameters:

[in]	pParentBody	Pointer to the parent rigid body, can be a null pointer
[in]	pChildBody	Pointer to the attached rigid body, can be a null pointer
[in]	vPivotPoint	Origin of the hinge in world space
[in]	vPinDir	The line of action of the hinge in world space

Returns:: The created physics joint, a null pointer on error (joint type not supported?)

See also:

CreateJointBall()

virtual Joint* PLPhysics::World::CreateJointUniversal	(	Body *	pParentBody,
		Body *	pChildBody,
		const PLMath::Vector3 &	vPivotPoint,
		const PLMath::Vector3 &	vPinDir1,
		const PLMath::Vector3 &	vPinDir2
	)		`[pure virtual]`

Creates a physics universal joint.

Parameters:

[in]	pParentBody	Pointer to the parent rigid body, can be a null pointer
[in]	pChildBody	Pointer to the attached rigid body, can be a null pointer
[in]	vPivotPoint	Origin of the universal in world space
[in]	vPinDir1	First axis of rotation fixed on THIS body and perpendicular to 'PinDir2' in world space
[in]	vPinDir2	Second axis of rotation fixed on 'Parent' body and perpendicular to 'PinDir1' in world space

Returns:: The created physics joint, a null pointer on error (joint type not supported?)

See also:

CreateJointBall()

virtual Joint* PLPhysics::World::CreateJointCorkscrew	(	Body *	pParentBody,
		Body *	pChildBody,
		const PLMath::Vector3 &	vPivotPoint,
		const PLMath::Vector3 &	vPinDir
	)		`[pure virtual]`

Creates a physics corkscrew joint.

Parameters:

[in]	pParentBody	Pointer to the parent rigid body, can be a null pointer
[in]	pChildBody	Pointer to the attached rigid body, can be a null pointer
[in]	vPivotPoint	Origin of the corkscrew in world space
[in]	vPinDir	The line of action of the corkscrew in world space

Returns:: The created physics joint, a null pointer on error (joint type not supported?)

See also:

CreateJointBall()

virtual Joint* PLPhysics::World::CreateJointUpVector	(	Body &	cParentBody,
		const PLMath::Vector3 &	vPinDir
	)		`[pure virtual]`

Creates a physics up vector joint.

Parameters:

[in]	cParentBody	Reference to the parent rigid body
[in]	vPinDir	The aligning vector in world space

Returns:: The created physics joint, a null pointer on error (joint type not supported?)

virtual Sensor* PLPhysics::World::CreateSensorRaycast	(	const PLMath::Vector3 &	vStart = `PLMath::Vector3::Zero`,
		const PLMath::Vector3 &	vEnd = `PLMath::Vector3::Zero`,
		PLCore::uint32	nFlags = `0`
	)		`[pure virtual]`

Creates a physics ray cast sensor.

Parameters:

[in]	vStart	Beginning of the ray in global space
[in]	vEnd	End of the ray in global space
[in]	nFlags	Flags (see Sensor::EFlags)

Returns:: The created physics sensor, a null pointer on error (sensor type not supported?)

virtual Sensor* PLPhysics::World::CreateSensorAABoundingBox	(	const PLMath::Vector3 &	vMin = `PLMath::Vector3::Zero`,
		const PLMath::Vector3 &	vMax = `PLMath::Vector3::Zero`,
		PLCore::uint32	nFlags = `0`
	)		`[pure virtual]`

Creates a physics axis aligned bounding box sensor.

Parameters:

[in]	vMin	Minimum of the axis aligned bounding box in global space
[in]	vMax	Maximum of the axis aligned bounding box in global space
[in]	nFlags	Flags (see Sensor::EFlags)

Returns:: The created physics sensor, a null pointer on error (sensor type not supported?)

virtual void PLPhysics::World::GetWorldSize	(	PLMath::Vector3 &	vMin,
		PLMath::Vector3 &	vMax
	)		const `[pure virtual]`

Returns the world size.

Parameters:

[out]	vMin	Receives the minimum world position
[out]	vMax	Receives the maximum world position

Remarks:: Some physics API's may need a given world size in order to work correct. So, set one for sure.

virtual void PLPhysics::World::SetWorldSize	(	const PLMath::Vector3 &	vMin = `PLMath::Vector3(-10000.0f,-10000.0f,-10000.0f)`,
		const PLMath::Vector3 &	vMax = `PLMath::Vector3(10000.0f, 10000.0f, 10000.0f)`
	)		`[pure virtual]`

Sets the world size.

Parameters:

[in]	vMin	Minimum world position
[in]	vMax	Maximum world position

See also:

GetWorldSize()

virtual bool PLPhysics::World::IsSimulationActive ( ) const [pure virtual]

Returns whether the simulation is currently active or not.

Returns:: 'true' if the simulation is currently active, else 'false'

Remarks:: If the physics simulation should be 'frozen', it's no good idea to skip just the UpdateSimulation() function because it's possible that the main physics processing is performed in another thread and this update function only performs state synchronization. So, in the case of just skipping this update function, the states visible to the user are not updated, but the physics itself is still running...

virtual void PLPhysics::World::SetSimulationActive ( bool bActive = true ) [pure virtual]

Sets whether the simulation is currently active or not.

Parameters:

[in] bActive 'true' if the simulation is currently active, else 'false'

See also:

IsSimulationActive()

virtual float PLPhysics::World::GetSimulationSpeed ( ) const [pure virtual]

Returns the simulation speed.

Returns:: The simulation speed

virtual bool PLPhysics::World::SetSimulationSpeed ( float fSpeed = 1.0f ) [pure virtual]

Sets the simulation speed.

Parameters:

[in] fSpeed The simulation speed, a speed of <= 0 is NOT allowed!

Returns:: 'true' if all went fine, else 'false' (maybe the given factor is <= 0?)

Note:

A speed of <= 0 is NOT allowed because this may cause problems in certain situations, deactivate the simulation instead by hand!
Do NOT make the speed 'too' (for example > 4) extreme, this may cause problems in certain situations!

virtual float PLPhysics::World::GetSimulationQuality ( ) const [pure virtual]

Returns the simulation quality.

Returns:: The simulation quality, 1 means best realistic behavior, 0 for the fastest possible configuration

virtual bool PLPhysics::World::SetSimulationQuality ( float fQuality = 1.0f ) [pure virtual]

Sets the simulation quality.

Parameters:

[in] fQuality The simulation quality, 1 means best realistic behavior, 0 for the fastest possible configuration

Returns:: 'true' if all went fine, else 'false' (maybe the quality factor is not within 0-1?)

virtual float PLPhysics::World::GetFrameRate ( ) const [pure virtual]

Returns the frame rate the simulation runs on.

Returns:: The frame rate the simulation runs on (>=60.0 and <=1000.0)

virtual bool PLPhysics::World::SetFrameRate ( float fFrameRate = 60.0f ) [pure virtual]

Sets the frame rate the simulation runs on.

Parameters:

[in] fFrameRate The frame rate the simulation runs on (>=60.0 and <=1000.0) (smaller=more performance, larger=more accurate simulation)

Returns:: 'true' if all went fine, else 'false' (maybe the given value is NOT between >=60.0 and <=1000.0 ?)

virtual void PLPhysics::World::GetGravity ( PLMath::Vector3 & vGravity ) const [pure virtual]

Returns the gravity vector.

Parameters:

[out] vGravity Will receive the current gravity vector

virtual void PLPhysics::World::SetGravity ( const PLMath::Vector3 & vGravity = PLMath::Vector3(0.0f,-9.81f, 0.0f) ) [pure virtual]

Sets the gravity vector.

Parameters:

[in] vGravity New gravity vector

virtual bool PLPhysics::World::GetGroupCollision	(	PLCore::uint8	nGroup1,
		PLCore::uint8	nGroup2
	)		const `[pure virtual]`

Returns whether collision is active between the two given collision groups or not.

Parameters:

[in]	nGroup1	First collision group(0-31)
[in]	nGroup2	Second collision group(0-31)

Returns:: 'true' if the collision between the two given collision groups is active, else 'false'

Note:

nGroup1 and nGroup2 are commutative
By default, collision between objects within the same group is disabled - except for the first group

virtual void PLPhysics::World::SetGroupCollision	(	PLCore::uint8	nGroup1,
		PLCore::uint8	nGroup2,
		bool	bActive = `true`
	)		`[pure virtual]`

Sets whether collision is active between the two given collision groups or not.

Parameters:

[in]	nGroup1	First collision group(0-31)
[in]	nGroup2	Second collision group(0-31)
[in]	bActive	'true' if the collision between the two given collision groups is active, else 'false'

See also:

GetGroupCollision()

virtual PLCore::uint8 PLPhysics::World::GetBodyPairFlags	(	const Body &	cBody1,
		const Body &	cBody2
	)		const `[pure virtual]`

Returns body pair flags.

Parameters:

[in]	cBody1	The first body
[in]	cBody2	The second body

Returns:: Body pair flags (see EBodyPairFlags)

Note:

GetBodyPairFlags() must NOT return the same flags set by SetBodyPairFlags()!
cBody1 and cBody2 are commutative

virtual void PLPhysics::World::SetBodyPairFlags	(	const Body &	cBody1,
		const Body &	cBody2,
		PLCore::uint8	nFlags = `0`
	)		`[pure virtual]`

Sets the body pair flags.

Parameters:

[in]	cBody1	The first body
[in]	cBody2	The second body
[in]	nFlags	Body pair flags (see EBodyPairFlags)

See also:

SetBodyPairFlags()

virtual bool PLPhysics::World::IsBuoyancyActive ( ) const [pure virtual]

Returns whether buoyancy force is used.

Returns:: 'true' if buoyancy force is used, else 'false'

virtual void PLPhysics::World::SetBuoyancyActive ( bool bActive = false ) [pure virtual]

Sets whether buoyancy force is used.

Parameters:

[in] bActive 'true' if buoyancy force is used, else 'false'

virtual float PLPhysics::World::GetBuoyancyPlaneY ( ) const [pure virtual]

Returns the y position of the buoyancy plane.

Returns:: The y position of the buoyancy plane

virtual void PLPhysics::World::SetBuoyancyPlaneY ( float fY = 0.0f ) [pure virtual]

Sets the y position of the buoyancy plane.

Parameters:

[in] fY New y position of the buoyancy plane

virtual void PLPhysics::World::UpdateSimulation ( ) [pure virtual]

Updates the simulation.

Remarks:: If the simulation should be 'frozen', do NOT just skip this function, use SetSimulationActive(false) instead!

See also:

SetSimulationActive()

virtual bool PLPhysics::World::IsAlwaysStatic ( ) const [pure virtual]

Returns whether the bodies are always static or not.

Returns:: 'true' if bodies are always static, else 'false'

Remarks:: During the creation of a body using for instance World::CreateBodyBox() you can give the used physics API a hint whether this body is always static or not. Some physics API's will use this information, while other not. The Newton and ODE physics plugins for instance will ignore this information, you can change the static state by setting a mass directly while 0 means static, while >0 indicates a dynamic body. The PhysX physics plugin for instance will use this information. If a body is created this static set to true, this body is always static within the API even if you set a mass!

Member Data Documentation

ContactInformation A contact between two bodies was detected by the physics Contact information as PLPhysics::World::parameter

The documentation for this class was generated from the following file:

World.h

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation