PhysicsManager (version 1.41)

index
d:\cruisecontrol\game-client-system\game\common\scripts\physicsmanager.py

This module behaves as a singleton allowing calls to the game physics system

 
Modules

      

 

SceneManager

gameGraphics

gamePhysics

 

 

 
Classes

      

 

Tool

Vehicle

SceneManager.Entity(SceneManager.MovableObject)

Body

exceptions.Exception(exceptions.BaseException)

PhysicsError

BodyError

ToolError

VehicleError

 
class Body(SceneManager.Entity)

   

 

Method resolution order:

Body

SceneManager.Entity

SceneManager.MovableObject


Methods defined here:

__init__(self, dic)

class initalization call that raises an error when called directly

attach(self, body, pos=[0, 0, 0], lforce=0, aforce=0)

Attaches the body to vehicles chassis position in local space where 
- force is the strenght of the attachement. Force must be positive or 0 value
- pos is the position and 
- body is the body instance

getData(self)

getEntity(self)

getOrientation(self)

getPosition(self)

setOrientation(self, w, x, y, z)

setPosition(self, x, y, z)


Data and other attributes defined here:

file = None

id = None

name = None


Methods inherited from SceneManager.Entity:

__str__(self)

Formated string describing name, file, animation names and position of the Entity

getAllAnimationNames(self)

Returns a list of all the animations supported by this entity.

playAnimation(self, name, loop=False, enabled=True)

Plays entity animation and returns None on success. Else raises an EntityError.

setMaterial(self, MaterialName)

Sets this entites material. Replaces the material currently in use.

stopAnimation(self, name)

Plays entity animation and returns None on success. Else raises an EntityError.


Methods inherited from SceneManager.MovableObject:

getChildren(self)

getDistanceTo(self, toObject)

Returns the distance to the object 'toObject'

getPitch(self)

Returns movable objects 'degree' around x axis

getRoll(self)

Returns movable objects 'degree' around z axis

getScale(self)

Returns movable objects scale in the form of a list having three float values [x, y, z]

getSize(self)

Returns movable objects size in the form of a list having three float values [x, y, z] after scale
(the bounding box size).

getYaw(self)

Returns movable objects 'degree' around y axis

rotate(self, w, x, y, z, time=None, args=None)

Rotates an object. Behaves exactly as setOrientation

scale(self, x, y, z)

Scales relative to current scale

setPitch(self, degree)

Rotates object 'degree' around x axis

setRoll(self, degree)

Rotates object 'degree' around z axis

setScale(self, x, y, z, relative=False)

Scales relative to current scale

setVisible(self, b=True, cascade=True)

if b is True then we set this object visable and all its children

setYaw(self, degree)

Rotates object 'degree' around y axis

showBoundingbox(self, b=True)

if b is true then we display this object bounding box

translate(self, x, y, z, time=None, args=None)

Moves movable object relative to its parent

 

 

 

 
class Tool

   

 

Methods defined here:

__init__(self, dic)

class initalization call that raises an error when called directly

attach(self, body, pa=[], pb=[])

Will attach body to this body pa, pb is the delta from center of object

getData(self)

getEntity(self)

setAction(self, a)

Where a is an integer action type that is know by the tool
Common values are in the range of -1 to 1

setBallisticsEffect(self, entity=None, sound=None, psys=None, ppos=None)

Sets the pre effect when the tool does not function due to some internal state (missing bullets or power less).
Where :
        entity is the ballistics entity created
        anim is name of the animation that this entity body currently has defined, returns error if not found. Default is None not used.
        sound is WeaponSound of the sound file to be played on success, returns error if not found. Default is None not used.
        psys is the name of the defined particle system, returns error if not found. Default is None not used.
        ppos is the position of the particle system in local coordinates (body position is null). Default is None not used.
This functions allows total control of what effect to be played out when the tool is used.

setDefaultEffect(self, anim=None, sound=None, psys=None, ppos=None, msec=0)

Sets the default effect when the tool is idle.
Where :
        anim is name of the animation that this entity body currently has defined, returns error if not found. Default is None not used.
        sound is WeaponSound of the sound file to be played on success, returns error if not found. Default is None not used.
        psys is the name of the defined particle system, returns error if not found. Default is None not used.
        ppos is the position of the particle system in local coordinates (body position is null). Default is None not used.
        sec is tool effect time and is 0 by default.
This functions allows total control of what effect to be played out when the tool is used.

setEnabled(self, b)

setNeoEffect(self, anim=None, sound=None, psys=None, ppos=None, msec=0)

Sets the neo (new ballistics or creation of) effect when the tool does executes the tool (more specifically after pre msec)
Where :
        anim is name of the animation that this entity body currently has defined, returns error if not found. Default is None not used.
        sound is WeaponSound of the sound file to be played on success, returns error if not found. Default is None not used.
        psys is the name of the defined particle system, returns error if not found. Default is None not used.
        ppos is the position of the particle system in local coordinates (body position is null). Default is None not used.
        sec is tool effect time and is 0 by default.
This functions allows total control of what effect to be played out when the tool is used.

setPostEffect(self, anim=None, sound=None, psys=None, ppos=None, msec=0)

Sets the post effect when the tool has finished executing the neo effect (more specifically after neo msec).
Where :
        anim is name of the animation that this entity body currently has defined, returns error if not found. Default is None not used.
        sound is WeaponSound of the sound file to be played on success, returns error if not found. Default is None not used.
        psys is the name of the defined particle system, returns error if not found. Default is None not used.
        ppos is the position of the particle system in local coordinates (body position is null). Default is None not used.
        sec is tool effect time and is 0 by default.
This functions allows total control of what effect to be played out when the tool is used.

setPreEffectFailure(self, anim=None, sound=None, psys=None, ppos=None, msec=0)

Sets the pre effect when the tool does not function due to some internal state (missing bullets or power less).
Where :
        anim is name of the animation that this entity body currently has defined, returns error if not found. Default is None not used.
        sound is WeaponSound of the sound file to be played on success, returns error if not found. Default is None not used.
        psys is the name of the defined particle system, returns error if not found. Default is None not used.
        ppos is the position of the particle system in local coordinates (body position is null). Default is None not used.
        sec is tool effect time and is 0 by default.
This functions allows total control of what effect to be played out when the tool is used.

setPreEffectSuccess(self, anim=None, sound=None, psys=None, ppos=None, msec=0)

Sets the pre effect when the tool successfully functions
Where :
        anim is name of the animation that this entity body currently has defined, returns error if not found. Default is None not used.
        sound is WeaponSound of the sound file to be played on success, returns error if not found. Default is None not used.
        psys is the name of the defined particle system, returns error if not found. Default is None not used.
        ppos is the position of the particle system in local coordinates (body position is null). Default is None not used.
        sec is tool effect time and is 0 by default.
This functions allows total control of what effect to be played out when the tool is used.

setRechargeEffect(self, anim=None, sound=None, psys=None, ppos=None, msec=0)

Sets the pre effect when the tool does not function due to some internal state (missing bullets or power less).
Where :
        anim is name of the animation that this entity body currently has defined, returns error if not found. Default is None not used.
        sound is WeaponSound of the sound file to be played on success, returns error if not found. Default is None not used.
        psys is the name of the defined particle system, returns error if not found. Default is None not used.
        ppos is the position of the particle system in local coordinates (body position is null). Default is None not used.
        sec is tool effect time and is 0 by default.
This functions allows total control of what effect to be played out when the tool is used.
Neither effects can be running when this is played


Data and other attributes defined here:

file = None

id = None

name = None

 

 

 
class Vehicle

   

Is the static and dynamic representation of our vehicle. The class requires calls to setup the vehicle data (will use default data if applicable)
and then during calls makeDynamic and makeStatic we create the actual vehicle based on this data.
Vehicle parts are represented using bolts and an vehicle part. If the vehicle mesh is omitted then no mesh and bolds are not created.
Vehicle parts are connected using bolts if mesh is NULL then no visual representation (entity) is created
 

 

Methods defined here:

__init__(self, name)

Creates a physical vehicle having name 'name' without wheels. The chassis is a default object and is 
changed by calling setChassis(...).

addAxis(self, type, meshName, zposition)

Will add an axis of type 'type' having mesh 'meshName'. The Mesh must be available
to the ogre resources.

addEnginePowerStep(self, ratio)

Adds a power step to the engine so that it will output value ratio*power at this step. The step position is set
with an internal call that increases and decreases with values set by calling setEngine(...).
This value must be 0 to 1 where 1 will be the maximum value set. There can be many steps taken for an engine to
reach 1. The first value should be 0 while the last is 1.
You can clear all steps by calling delEnginePowerSteps(...). 
Raises VehicleError on failure.

addWheel(self, type, meshName)

Raises VehicleError on failure.

attach(self, body, pos=[0, 0, 0], lforce=0, aforce=0)

Attaches the body to vehicles chassis position in local space where 
- force is the strenght of the attachement. Force must be positive or 0 value
- pos is the position and 
- body is the body instance

delEnginePowerSteps(self)

Clears engine steps added during call of addEnginePowerStep(...). Will revert to linear increase of power.

delWheel(self, type)

Removes the wheel from current vehicle setup. Raises VehicleError if the wheel does not exist.
Raises VehicleError if the wheel does not exist.

destroy(self)

Removes the vehicle and current attached parts to the vehicle such as wheel, engine, suspension, chassis, etc ...

getCorrection(self)

Gets this vehicles correct possition and rotation. This is used to update the network simulated
vehicles. Returns [[x, y ,z],[w, x, y, z]] formated string.

getDeadreconing(self)

getMaterial(self, part)

Returns the assinged material of the requested part. None if no material was defined for the part.
The successfull return value is material name

getName(self)

getOrientation(self)

Returns a quaternion of the vehicles orientation

getPartName(self, part)

Gets this vehicles generated name of the parts entity. The Parameter part must be one of 
these supported strings: 'chassi' and 'tire'

getPosition(self)

Gets the vehicles position in global space.

getRotation(self)

Returns a array having [x,y,z] degree rotations
__MovableObjectProperty_Yaw = 4
__MovableObjectProperty_Roll = 5
__MovableObjectProperty_Pitch = 6

isDynamic(self)

makeDynamic(self)

Makes the actual vehicle according to the specified settings set through the set calls.
The representation is dynamic meaning it will be drivable and behave as an vehicle depending
on the settings.

makeStatic(self)

Makes the an static vehicle according to the specified settings set through the set calls.
The representation is static meaning it will NOT be drivable.

setAxisBolt(self, type, boltName, meshName, offset=[0, 0, 0])

Creates and attaches an bolt to the axis. The axis 'type' is either 'FrontLeft', 'FrontRight', 'RearLeft' or 'RearRight' denoting the location of the axis.
The 'boltName' is used to connect another vehicle part to this bold.
The bolt is sort of a market that is used to identify the location. 
'meshName' is the visual representation. The meshName must be an resource available mesh or null. If null no mesh
is used.
'offset' is a three dimensional location relative to the parent 'chassis' center (or in other words, parent space).
Raises VehicleError on failure

setBrake(self, axis, force=100)

Sets the vehicle brake force. May not be negative null value and axis is either 'Front' or 'Rear'
Raises VehicleError on failure.

setChassis(self, mesh, mass, massoffset=[0, -1, 0])

Sets the vehicles chassis to be mesh having mass and an massoffset
Where mass must be a positive value. The mesh must exist in resources.

setChassisBolt(self, boltName, meshName, offset=[0, 0, 0])

Creates and attaches an bolt to the chassis. The 'boltName' is used to connect another vehicle part to this bold.
The bolt is sort of a market that is used to identify the location. 
'meshName' is the visual representation. The meshName must be an resource available mesh or null. If null no mesh
is used.
'offset' is a three dimensional location relative to the parent 'chassis' center (or in other words, parent space).
Raises VehicleError on failure

setControlArmBehavior(self, axisType, controlArmTravel)

Sets the control arm behavoir where 
axisType is either 'FrontLeft', 'FrontRight', 'RearLeft', 'RearRightand
controlArmTravel is larger than zero.
Raises VehicleError on failure

setControlArmMotion(self, axisType, boltType, meshName, pivotOffset=[0, 0, 0], behavior='Connect')

Creates an visual representation of the control arm (can be omitted). Where 
axisType is either 'FrontLeft', 'FrontRight', 'RearLeft', 'RearRight'
boltType is created through calls setChassisBolt and setAxisBolt
meshName if name of file that is accessable by ogre resource system.
pivotSystem has three float values positioning the pivot of the vehicle part (where pivot is the axis which we rotate around)
behavoir is either 'Connect' ... TBD
If this call is not called then no visual representation will be created for this vehicle part but it will
function properly.
Raises VehicleError on failure

setCorrection(self, posrot)

Corrects the vehicle position and orientation if needed where posrot is a string having 
format [[x, y ,z],[w, x, y, z]]. This string is turned into 
two arrays. First having 3 values (x,y,z) and the second having quaternion (w,x,y,z). 
Returns true if correction was made false if no correction was needed.

setDeadreconing(self, data)

setDriveShaftMotion(self, axisType, boltType, meshName, pivotOffset=[0, 0, 0], behavior='Connect')

Creates an visual representation of the drive shaft (can be omitted). Where 
axisType is either 'FrontLeft', 'FrontRight', 'RearLeft', 'RearRight'
boltType is created through calls setChassisBolt and setAxisBolt
meshName if name of file that is accessable by ogre resource system.
pivotSystem has three float values positioning the pivot of the vehicle part (where pivot is the axis which we rotate around)
behavoir is either 'Connect' ... TBD
If this call is not called then no visual representation will be created for this vehicle part but it will
function properly.
Raises VehicleError on failure

setEngine(self, power, increase, decrease)

Sets the vehicles engine properties where power is the maximum power through output and increase / decrease is the speed in with the
engine increase and decrease
 its output. These are values must be larger than 0 (good values are 60, 0.8, 1). They decide how fast the engine

will go from 0% to 100% during gas intake and gas halt. Where at 100% it will give defined power.
Call addPowerStep to tune how much the engine will output at these steps.
Raises VehicleError on failure.

setMaterial(self, part, material)

Sets this vehicles generated entities to te specified material 'material' of the vehicle. 
The parameter 'part' must be one of these supported strings: see getPartName.
Raises VehicleError on failure. Stores the material on success and can be reassigned through call useMaterial()

setOrientation(self, w, x, y, z)

Sets the vehicles orientation of type quaternion in global space.

setPosition(self, x, y, z)

Sets the vehicles position in global space. The y position will be calculated "ground height + y". If y is None we use the ground height for y.

setShockAbsorberBehavior(self, axisType, shockAbsorberDamper, shockAbsorberTarget)

Sets the control arm behavoir where 
axisType is either 'FrontLeft', 'FrontRight', 'RearLeft', 'RearRight' and
shockAbsorberDamper is larger than zero and
shockAbsorberTarget is between zero and one.
Raises VehicleError on failure

setShockAbsorberMotion(self, axisType, boltType, meshName, pivotOffset=[0, 0, 0], behavior='Connect')

Creates an visual representation of the shock absorber (can be omitted). Where 
axisType is either 'FrontLeft', 'FrontRight', 'RearLeft', 'RearRight'
boltType is created through calls setChassisBolt and setAxisBolt
meshName if name of file that is accessable by ogre resource system.
pivotSystem has three float values positioning the pivot of the vehicle part (where pivot is the axis which we rotate around)
behavoir is either 'Connect' ... TBD
If this call is not called then no visual representation will be created for this vehicle part but it will
function properly.
Raises VehicleError on failure

setSteer(self, SteerServoIncrease=4, SteerServoDecrease=4, SteerMax=0.59999999999999998, RotateOwnAxisOnStop=0)

Sets the servo steering of the wheels. Where SteerServoIncrease is the speed in which we turn the wheel and SteerServoDecrease is the
speed the wheels restores themselfs when player stops steering. SteerMax is the maximum angle (in radians) that we may steer at either direction.
The speed in which we turn must be not null positive values and SteerMax maximum value is 1.4 (80 degrees).
Raises VehicleError on failure.

setSuspensionBehavior(self, axisType, suspensionSpring)

Sets the control arm behavoir where 
axisType is either 'Front' or 'Rear' and
suspensionSpring is larger than zero.
Raises VehicleError on failure

setSuspensionMotion(self, axisType, boltType, meshName, pivotOffset=[0, 0, 0], behavior='Connect')

Creates an visual representation of the suspenion (can be omitted). Where 
axisType is either 'FrontLeft', 'FrontRight', 'RearLeft', 'RearRight'
boltType is created through calls setChassisBolt and setAxisBolt
meshName if name of file that is accessable by ogre resource system.
pivotSystem has three float values positioning the pivot of the vehicle part (where pivot is the axis which we rotate around)
behavoir is either 'Connect' ... TBD
If this call is not called then no visual representation will be created for this vehicle part but it will
function properly.
Raises VehicleError on failure

setTireBehavior(self, axis, LateralAsymptoteSlip, LateralAsymptoteValue, LateralExtremumSlip, LateralExtremumValue, LongitudalAsymptoteSlip, LongitudalAsymptoteValue, LongitudalExtremumSlip, LongitudalExtremumValue)

The behavior of the tire is dependent on these values. They are used to calculate the grip with relation to force and wheel rotation.
See PhysX documentation on NxWheelShape for detailed information.
'axis' is either 'Front' or 'Rear'. 
LateralAsymptoteSlipLateralAsymptoteValueLateralExtremumSlipLateralExtremumValue.
LongitudalAsymptoteSlipLongitudalAsymptoteValueLongitudalExtremumSlipLongitudalExtremumValue.
Must be positive values, LateralExtremumSlip < LateralAsymptoteSlip and LongitudalExtremumSlip < LongitudalAsymptoteSlip
Raises VehicleError on failure.

setTireGrip(self, axis, longitudal, lateral)

Sets the vehicle tires grip on 'axis' where axis is either 'Front' or 'Rear'. 
The grip is the stiffness factor dependent on force.
Must have positive values. Raises VehicleError on failure.

setWheelBehavior(self, axisType, mass, massinv)

Sets the wheel behavior through mass and mass inverted values. Where 
axisType is either 'FrontLeft', 'FrontRight', 'RearLeft', 'RearRight' and
mass and massinv is not negative values.

setWheelParticles(self, particleMaterial='', channel=0, delta=0)

Sets the vehicles wheel particle material. The material must be loaded or loadable by Ogre. 
The material will be set to the wheel imidiatly and used when driving depending on settings provided. 
Where particleMaterial is the name of an existing accessable ogre material
and channel is the channel to be assigned the particles (channels are integer values from 0 to 3)
and delta is the delta value to be added where we start our emission from (for instance if rotation 
power is .3 and this is .5 then output will be .8)
If particleMaterial is NULL ('') then the particles for channel 'channel' is removed.
Raises VehicleError on failure.

setWheelTracks(self, materialName)

Sets vehicles wheel track material. The material named 'materialName' must be loaded by Ogre. 
The material named 'materialName' will imidiatly be used on current tracks. 
If null then wheel tracks are disabled.

useMaterial(self)

Will use the previus assigned material on all the objects. This is mainly so we do not need to 
get the information again (we just reuse it).
Raises VehicleError if dictionary was not set at all (no succesfull call to setMaterial was made)


Data and other attributes defined here:

file = None

name = None

types = {'FrontLeft': [0, False], 'FrontRight': [0, True], 'RearLeft': [1, False], 'RearRight': [1, True]}

 

 

 

 
Functions

      

 

addBall(name, meshfile, mass=10, position=[0, 0, 0], static=False, radius=None)

Creates a ball having using meshfile as the representation.
If mass is not set then it will use 10 as default.
If radius is not set then it will use meshes radius as default radius
If position is not set then we use default 0,0,0

addBox(name, meshfile, mass=10, position=[0, 0, 0], static=False, size=None)

Creates a ball having using meshfile as the representation.
If mass is not set then it will use 10 as default.
If size is not set then it will use meshes size as default size
If position is not set then we use default 0,0,0
If static is true then we create a static object else not.

addCapsule(name, meshfile, mass=10, position=[0, 0, 0], static=False, dim=None)

Creates a capsule having using meshfile as the representation.
If mass is not set then it will use 10 as default.
If position is not set then we use default 0,0,0
If static is True then we create an static mesh else not.
If dim is set then we do not use the mesh dimension but the array of values that 
must have 2 values [x,y]

addCar(name)

Creates a vehicle instance and returns it to the caller.

addGunTool(name, meshfile, force=1000, mass=10, distance=1000, position=[0, 0, 0])

Creates a gun tool having using meshfile as the representation.
Where distance is the range of our gun. Objects outside the range is not effected
If mass is not set then it will use 10 as default.
If size is not set then it will use meshes size as default size
If position is not set then we use default 0,0,0
If static is true then we create a static object else not.

addMagnetTool(name, meshfile, force=1000, mass=10, distance=1000, position=[0, 0, 0])

Creates a gun tool having using meshfile as the representation.
Where distance is the range of our gun. Objects outside the range is not effected
If mass is not set then it will use 10 as default.
If size is not set then it will use meshes size as default size
If position is not set then we use default 0,0,0
If static is true then we create a static object else not.

addMesh(name, meshfile, mass=10, position=[0, 0, 0], static=False)

Creates a capsule having using meshfile as the representation.
If mass is not set then it will use 10 as default.
If position is not set then we use default 0,0,0
If static is True then we create an static mesh else not.
Note that the mesh must be convex and follow PhysX requirements.

addPath(name, spline, materialName, deltaY=0.29999999999999999, width=20, orientation=[1, 0, 0, 0])

Adds a bezier path with name 'name' having zero points.
The path sides will be as close to the ground as possible.
Raises SceneError on failure.
Returns None on success.

addPrism(name, meshfile, mass=10, position=[0, 0, 0], dim=[1, 1, 5], static=False)

Creates a capsule having using meshfile as the representation.
If mass is not set then it will use 10 as default.
If position is not set then we use default 0,0,0
If static is True then we create an static mesh else not.
Dim must be an array of three values defining the width, height and side count

addRocketTool(name, meshfile, force=1000, mass=10, distance=1000, position=[0, 0, 0])

Creates a rocket tool having using meshfile as the representation.
Where distance is the speed of the rocket.
If mass is not set then it will use 10 as default.
If size is not set then it will use meshes size as default size
If position is not set then we use default 0,0,0
If static is true then we create a static object else not.

addTool(tooltype, name, meshfile, force=1000, mass=10, distance=1000, position=[0, 0, 0])

Creates a tool having using meshfile as the representation.
Where distance is the range of our gun. Objects outside the range is not effected
If mass is not set then it will use 10 as default.
If size is not set then it will use meshes size as default size
If position is not set then we use default 0,0,0
If static is true then we create a static object else not.

createWorld(HasFloor='', bHasGravity=True)

HasFloor takes a file name that represent its area. If config file is '' (nothing) then we create a floor at height 0.
Creates a physical world returning None. Raises PhysicsError on failure

debugEnabled(b, ip='127.0.0.1')

delBody(name)

Destorys the body and removes from scene. An body is created through calls
addBall(), addBox(), addMesh(), addCapsule(), addPrism()

delCar(name, dic)

delPath(name)

Destroys a bezier path with name 'name'
Raises SceneError on failure.
Returns None on success.

delTool(name)

Creates a tool having using meshfile as the representation.
Where distance is the range of our gun. Objects outside the range is not effected
If mass is not set then it will use 10 as default.
If size is not set then it will use meshes size as default size
If position is not set then we use default 0,0,0
If static is true then we create a static object else not.

destroyWorld()

Destroys a physical world and all of its physical contents if it exists returning None. 
Raises PhysicsError on failure

getBody(name)

getCar(name)

Returns the car having id 'name' if it exists. Else returns None.

getCarNames()

Return all the loaded vehicle names

getMarker()

A marker is an object that follows the ground in front of the camera (used for editing).
A marker is created through call useMarker()
Returns the position of the terrain marker

isCarPresent(name)

setAreaProperty(dic, x=None, y=None)

NOT SUPPORTED
Sets an area property flusing the 'dic' into the system. The 'dic' attribute and values must be supported
otherwise we raise SceneError exception.
x and y is the page we assign the attributes onto. If omited we assign over the entire area.
'dic' should use supported attributes and values. If we are describing something we should describe it fully.
Currently we support 'define' of 'grass' and 'tree' where 
    'tree' input values are 'DetailLevelHigh' 'DetailLevelMedium', 'DetailLevelLow', 'DetailLevelCount', 'MeshName', 'RandomScaleMax' and 'RandomScaleMin'.
    'grass' input values are 'Density', 'DetailLevel', 'ColorMap', 'DensityMap', 'SizeMaxX','SizeMaxY','SizeMinX','SizeMinY','MaterialName','Radius','RandomScaleMax','RandomScaleMin','SwayDistribution','SwayLength','SwaySpeed'

setAreaRegion(descr)

descr is a xml file that we load with the region configuration.

setCar(name, dic, deadreconing=None)

useMarker(meshName=None)

A marker is an object that follows the ground in front of the camera (used for editing).
Will enable/disable a terrain marker over a terrain. The marker is enabled if meshName is defined.
Passing None or '' will disable the marker.
Raises PhysicsError on failure.

 

 
Data

      

 

__author__ = 'Kjartan A Jonsson'
__copyright__ = 'Copyright (c) 2007 aGameCompany'
__license__ = 'aGameCompany'
__version__ = '$Revision: 1.41 $'

 

 
Author

      

 

Kjartan A Jonsson