
'''
Stub class file for:
OpenMayaFX

Maya2011 Python API stub file
Generated from original Maya documentation.
Autodesk Maya 2010  c1997-2010 Autodesk, Inc. All rights reserved. 
'''




class MnCloth:
    '''Class for wrapping N cloth objects.'''
    def __init__(self):
        pass


    def getFriction(self, friction): 
        '''getFriction(self, friction)
Arguments:
	[out]	friction = MFloatArray

gets the friction at each point of the underlying N cloth
object.'''
        pass

    def setInputMeshAttractPositions(self, positions): 
        '''setInputMeshAttractPositions(self, positions)
Arguments:
	[in]	positions = MFloatPointArray

Sets the positions for input mesh attract'''
        pass

    def getBounce(self, bounce): 
        '''getBounce(self, bounce)
Arguments:
	[out]	bounce = MFloatArray

gets the bounce at each point of the underlying N cloth
object.'''
        pass

    def setInputMeshAttractDamping(self, damping): 
        '''setInputMeshAttractDamping(self, damping)
Arguments:
	[in]	damping = float

Defines how springy the effect of Input Mesh Attract is. At a
value of zero input mesh attract will behave like a spring
connection from the input mesh to the output dynamic mesh. The
cloth will tend to wiggle about the input mesh position. As the
Input Attract Damp is increased to 1 the cloth mesh will still move
to the input mesh position but not have the momentum to travel past
it, so will no longer occillate about the input position.'''
        pass

    def setTangentialDrag(self, tangentialDrag): 
        '''setTangentialDrag(self, tangentialDrag)
Arguments:
	[in]	tangentialDrag = float

Sets the tangential drag values for the cloth. Defines the
component of drag tangent to the surface. With a value of zero a
flat plane will slice through air with no resistance and only have
drag when moving along its normal axis. With a value of 1.0 the
effect of drag will be equal in all directions.'''
        pass

    def setThickness(self, radius): 
        '''setThickness(self, radius)
Arguments:
	[in]	radius = float

sets a radius (thickness) on a per point basis for the mesh for
collision purposes. The bigger the radius, the more easily things
collide.'''
        pass

    def getNumVertices(self, numVerts): 
        '''getNumVertices(self, numVerts)
Arguments:
	[out]	numVerts = int

Returns the number of vertices in the underlying n Cloth'''
        pass

    def setInverseMass(self, invMass): 
        '''setInverseMass(self, invMass)
Arguments:
	[in]	invMass = float

sets the mass on a per point basis in this mesh'''
        pass

    def setSelfCollisionSoftness(self, softness): 
        '''setSelfCollisionSoftness(self, softness)
Arguments:
	[in]	softness = float

This allows one to lower the repulsive force of self collisions
such that some interpenetration within the collide width is
allowed. This can in some cases reduce jitter due to self collision
with low selfCollideIterations. In general its use should be
avoided, however.'''
        pass

    def setSealHoles(self, seal): 
        '''setSealHoles(self, seal)
Arguments:
	[in]	seal = bool

When the volume tracking pressure method is used this determines
if physical holes in the cloth model are treated as being capped or
not. If holes are not sealed, then air can escape out them, which
also has the effect of pushing the cloth. For example, this can
simulate a rubber balloon that is suddenly released. It also allows
for inflow based on motion of the cloth. The opening in a parachute
will allow air to flow in as it falls down, causing sideways
pressure that inflates it. Note that drag alone cannot achieve this
sort of effect'''
        pass

    def setSelfCollideWidth(self, width): 
        '''setSelfCollideWidth(self, width)
Arguments:
	[in]	width = float

Sets the self collision width'''
        pass

    def setBendRestAngleFromPositions(self, positions): 
        '''setBendRestAngleFromPositions(self, positions)
Arguments:
	[in]	positions = MFloatPointArray

Sets the the bend rest angle from the list of positions for the
underlying N Object This sets the shape that bend resistance is
trying to achieve.'''
        pass

    def setShearResistance(self, resistance): 
        '''setShearResistance(self, resistance)
Arguments:
	[in]	resistance = float

Sets the shear resistance. Shear can be thought of as the bend
in the plane of the cloth.'''
        pass

    def setPressureDamping(self, damp): 
        '''setPressureDamping(self, damp)
Arguments:
	[in]	damp = float

Sets the damping value for pressure'''
        pass

    def setDamping(self, damping): 
        '''setDamping(self, damping)
Arguments:
	[in]	damping = float

sets the on a per point basis in this mesh'''
        pass

    def setTrackVolume(self, track): 
        '''setTrackVolume(self, track)
Arguments:
	[in]	track = bool

'''
        pass

    def setSelfCrossoverPush(self, val): 
        '''setSelfCrossoverPush(self, val)
Arguments:
	[in]	val = float

See node documentation.'''
        pass

    def setInputMeshAttractAndRigidStrength(self, inputAttractArray, rigidArray, deformArray): 
        '''setInputMeshAttractAndRigidStrength(self, inputAttractArray, rigidArray, deformArray)
Arguments:
	[in]	inputAttractArray = float
	[in]	rigidArray = float
	[in]	deformArray = float

Sets on a per particle basis, the amount by which each particle
is affected by the input mesh attract, rigidity, and deformability.
High values for the input mesh attract will make points stick
closely to the input mesh. High values for the rigidArray will make
the object behave like a rigid body.'''
        pass

    def setRestitutionTension(self, tension): 
        '''setRestitutionTension(self, tension)
Arguments:
	[in]	tension = float

How far can the links be stretched before they fail to go back
to their rest length when there are no forces acting on the cloth.
When the tension is greater than the defined value the defined rest
length will increase until the tension is equal this value. For
very low values the material will pull apart like taffy, yet still
resist stretching under mild forces.'''
        pass

    def createNCloth(self): 
        '''createNCloth(self)
Creates the underlying Maya TnCloth and sets this class to wrap
it.'''
        pass

    def setLinksRestLengthFromPositions(self, positions): 
        '''setLinksRestLengthFromPositions(self, positions)
Arguments:
	[in]	positions = MFloatPointArray

Sets the the rest length from the list of positions for the
underlying N Object. This sets the shape that the
stretch/compression resistance are trying to achieve.'''
        pass

    def setIncompressibility(self, v): 
        '''setIncompressibility(self, v)
Arguments:
	[in]	v = float

When the volume tracking pressure model is used this defines how
incompressible the internal volume of fluid is. This also will
affect how much force is applied to the cloth when air is pumped
in. In the case of a balloon higher values of incompressibility
will overcome higher stretch resistance. Note that higher
incompressibility may require more calculation time.'''
        pass

    def setPressure(self, pressure): 
        '''setPressure(self, pressure)
Arguments:
	[in]	pressure = float

Sets the pressure within the cloth. This defines a force applied
along the surface normal direction'''
        pass

    def setAddCrossLinks(self, addCrossLinks): 
        '''setAddCrossLinks(self, addCrossLinks)
Arguments:
	[in]	addCrossLinks = float

For faces with more than 3 vertices this will create additional
stretch and bends links such that each vertex is connected to each
other vertex. If this is off then the links will exactly match the
meshes list of edges. For a quad meshes having addCrossLinks off
would allow the cloth to shear, unless shear resistance was
used.'''
        pass

    def setBendAngleScale(self, scale): 
        '''setBendAngleScale(self, scale)
Arguments:
	[in]	scale = float

Defines the amount by which the rest state of the bend angle is
scaled.'''
        pass

    def setTopology(self, numFaces, numVertsPerFace, faces, numEdges, edges): 
        '''setTopology(self, numFaces, numVertsPerFace, faces, numEdges, edges)
Arguments:
	[in]	numFaces = int
	[in]	numVertsPerFace = int
	[in]	faces = int
	[in]	numEdges = int
	[in]	edges = int

sets the topology of the underlying N Object. Before calling
other methods, this must be the first method you call once the
cloth object is created.'''
        pass

    def setComputeRestAngles(self, b): 
        '''setComputeRestAngles(self, b)
Arguments:
	[in]	b = bool

Sets whether rest angles will be automatically computed, or
overridden manually. If this is set to false, then you must call
 setBendRestAngleFromPositions() 
to set the rest lengths.'''
        pass

    def setSelfTrappedCheck(self, on): 
        '''setSelfTrappedCheck(self, on)
Arguments:
	[in]	on = bool

This tracks self collision crossovers and attempts to push the
crossed over points back. It assumes that the surface is in a good
state at the start and attempts to preserve that relative state. It
is useful in cases where cloth can get caught between passive
objects than interpenetrate (for example an elbow passing through a
chest). Rather than get stuck on the wrong side this allows the
cloth to push back to the correct side when the passive objects
later separate.'''
        pass

    def getPositions(self, positions): 
        '''getPositions(self, positions)
Arguments:
	[out]	positions = MFloatPointArray

gets the positions of the points of the underlying N Object.'''
        pass

    def setSelfCollisionFlags(self, vertToVert, vertToEdge, vertToFace, edgeToEdge, edgeToFace): 
        '''setSelfCollisionFlags(self, vertToVert, vertToEdge, vertToFace, edgeToEdge, edgeToFace)
Arguments:
	[in]	vertToVert = bool
	[in]	vertToEdge = bool
	[in]	vertToFace = bool
	[in]	edgeToEdge = bool
	[in]	edgeToFace = bool

Sets how (or if) this object will collide with itself.'''
        pass

    def setStartPressure(self, startPressure): 
        '''setStartPressure(self, startPressure)
Arguments:
	[in]	startPressure = float

With the volume tracking pressure method this defines the
relative air pressure inside the object at the startframe.'''
        pass

    def setBendResistance(self, strength): 
        '''setBendResistance(self, strength)
Arguments:
	[in]	strength = float

Bend resistance measures the amount of attraction to the
restAngle, which is defined between cvs on either side of an edge.
Larger values will tend to make the surface more rigid and will
take longer to compute.'''
        pass

    def getVelocities(self, velocities): 
        '''getVelocities(self, velocities)
Arguments:
	[out]	velocities = MFloatPointArray

gets the velocities of the points of the underlying N cloth
object.'''
        pass

    def setVelocities(self, velocities): 
        '''setVelocities(self, velocities)
Arguments:
	[in]	velocities = MFloatPointArray

Sets the velocities of the vertices of the underlying Ncloth
object'''
        pass

    def setPositions(self, positions, startFrame): 
        '''setPositions(self, positions, startFrame)
Arguments:
	[in]	positions = MFloatPointArray
	[in]	startFrame = bool

Sets the positions of the vertices of the underlying N cloth
object'''
        pass

    def getInverseMass(self, inverseMass): 
        '''getInverseMass(self, inverseMass)
Arguments:
	[out]	inverseMass = MFloatArray

gets the inverseMass at each point of the underlying N cloth
object.'''
        pass

    def setBendAngleDropoff(self, dropoff): 
        '''setBendAngleDropoff(self, dropoff)
Arguments:
	[in]	dropoff = float

Defines the way bend resistance changes with the angle. At
higher values the bend will resist more at high angles then when
the surface is nearly flat.'''
        pass

    def setMaxSelfCollisionIterations(self, it): 
        '''setMaxSelfCollisionIterations(self, it)
Arguments:
	[in]	it = int

Sets the number of iterations the solver will perform for self
collisions on this object.'''
        pass

    def setDragAndLift(self, drag, lift): 
        '''setDragAndLift(self, drag, lift)
Arguments:
	[in]	drag = float
	[in]	lift = float

Sets the drag and lift values for the cloth'''
        pass

    def setAirTightness(self, airTightness): 
        '''setAirTightness(self, airTightness)
Arguments:
	[in]	airTightness = float

Defines the rate at which air can escape from the object, or how
permiable the surface is. This is in addition to any physical holes
in the model, which can be be capped or not using the seal holes
method.'''
        pass

    def setStretchAndCompressionResistance(self, stretchResist, compressionResist): 
        '''setStretchAndCompressionResistance(self, stretchResist, compressionResist)
Arguments:
	[in]	stretchResist = float
	[in]	compressionResist = float

Sets the stretch and compression resistance for the mesh on a
per vertex basis'''
        pass

    def setBounce(self, bounce): 
        '''setBounce(self, bounce)
Arguments:
	[in]	bounce = float

sets the bounce on a per point basis in this mesh'''
        pass

    def setFriction(self, friction): 
        '''setFriction(self, friction)
Arguments:
	[in]	friction = float

sets the friction on a per point basis for this mesh'''
        pass

    def setRestitutionAngle(self, angle): 
        '''setRestitutionAngle(self, angle)
Arguments:
	[in]	angle = float

Defines how far we can bend across an edge before it will fail
to go back to the rest angle when there are no forces acting on the
cloth.'''
        pass

    def setComputeRestLength(self, b): 
        '''setComputeRestLength(self, b)
Arguments:
	[in]	b = bool

Sets whether rest lengths will be automatically computed, or
overridden manually. If this is set to false, then you must call
 setLinksRestLengthFromPositions() 
to set the rest lengths.'''
        pass

    def getThickness(self, radius): 
        '''getThickness(self, radius)
Arguments:
	[out]	radius = MFloatArray

gets the thickness at each point of the underlying N cloth
object.'''
        pass

    def setCollisionFlags(self, vertToVert, edgeToEdge, faceToFace): 
        '''setCollisionFlags(self, vertToVert, edgeToEdge, faceToFace)
Arguments:
	[in]	vertToVert = bool
	[in]	edgeToEdge = bool
	[in]	faceToFace = bool

Sets how (or if) this object will collide with other
objects.'''
        pass

    def setPumpRate(self, pump): 
        '''setPumpRate(self, pump)
Arguments:
	[in]	pump = float

Defines the rate at which air pressure is added to the
object'''
        pass

    def setMaxIterations(self, it): 
        '''setMaxIterations(self, it)
Arguments:
	[in]	it = int

Sets the number of iterations the solver will perform on various
dynamic properties like drag, damping, stretch and bend. Higher
iterations take longer, and the primary use of this attribute is to
keep things from locking up should high iteration values be
requested.'''
        pass

    def setDisableGravity(self, b): 
        '''setDisableGravity(self, b)
Arguments:
	[in]	b = bool

Sets whether gravity will affect this object'''
        pass

class MnObject:
    '''Class for wrapping N cloth objects.'''
    def __init__(self):
        pass


class MnParticle:
    '''Class for wrapping N cloth objects.'''
    def __init__(self):
        pass


    def getFriction(self, friction): 
        '''getFriction(self, friction)
Arguments:
	[out]	friction = MFloatArray

gets the friction of the points of the underlying N particle
object.'''
        pass

    def getBounce(self, bounce): 
        '''getBounce(self, bounce)
Arguments:
	[out]	bounce = MFloatArray

gets the Bounce of the points of the underlying N particle
object.'''
        pass

    def setThickness(self, radius): 
        '''setThickness(self, radius)
Arguments:
	[in]	radius = float

sets a radius (thickness) on a per point basis for collision
purposes. The bigger the radius, the more easily things
collide.'''
        pass

    def createNParticle(self): 
        '''createNParticle(self)
Creates the underlying Maya TnParticle and sets this class to
wrap it.'''
        pass

    def setSelfCollide(self, b): 
        '''setSelfCollide(self, b)
Arguments:
	[in]	b = bool

Sets whether self collisions will affect this object'''
        pass

    def setSelfCollideWidth(self, width): 
        '''setSelfCollideWidth(self, width)
Arguments:
	[in]	width = float

Sets the self collision width'''
        pass

    def setLiquidSimulation(self, b): 
        '''setLiquidSimulation(self, b)
Arguments:
	[in]	b = bool

Sets whether this object will solve as a liquid'''
        pass

    def getNumVertices(self, numVerts): 
        '''getNumVertices(self, numVerts)
Arguments:
	[out]	numVerts = int

Returns the number of vertices in the underlying nParticle'''
        pass

    def setDamping(self, damping): 
        '''setDamping(self, damping)
Arguments:
	[in]	damping = float

sets the damping on a per point basis in this mesh'''
        pass

    def setCollide(self, b): 
        '''setCollide(self, b)
Arguments:
	[in]	b = bool

Sets whether collisions will affect this object'''
        pass

    def setViscosity(self, viscosity): 
        '''setViscosity(self, viscosity)
Arguments:
	[in]	viscosity = float

sets the viscosity on a per point basis in this mesh'''
        pass

    def setRestDensity(self, restDensity): 
        '''setRestDensity(self, restDensity)
Arguments:
	[in]	restDensity = float

sets the rest density for every point in this mesh'''
        pass

    def setIncompressibility(self, incompressibility): 
        '''setIncompressibility(self, incompressibility)
Arguments:
	[in]	incompressibility = float

sets the incompressibility'''
        pass

    def setTopology(self, numPoints): 
        '''setTopology(self, numPoints)
Arguments:
	[in]	numPoints = int

Sets the topology of the underlying N Object. This must be
called whenever the number of particles changes, before setting any
particle properties'''
        pass

    def getPositions(self, positions): 
        '''getPositions(self, positions)
Arguments:
	[out]	positions = MFloatPointArray

gets the positions of the points of the underlying N Object.'''
        pass

    def setInverseMass(self, invMass): 
        '''setInverseMass(self, invMass)
Arguments:
	[in]	invMass = float

sets the mass on a per point basis'''
        pass

    def getVelocities(self, velocities): 
        '''getVelocities(self, velocities)
Arguments:
	[out]	velocities = MFloatPointArray

gets the velocities of the points of the underlying N cloth
object.'''
        pass

    def setVelocities(self, velocities): 
        '''setVelocities(self, velocities)
Arguments:
	[in]	velocities = MFloatPointArray

Sets the velocities of the vertices of the underlying Ncloth
object'''
        pass

    def setPositions(self, positions, startFrame): 
        '''setPositions(self, positions, startFrame)
Arguments:
	[in]	positions = MFloatPointArray
	[in]	startFrame = bool

Sets the positions of the vertices of the underlying N cloth
object'''
        pass

    def getInverseMass(self, inverseMass): 
        '''getInverseMass(self, inverseMass)
Arguments:
	[out]	inverseMass = MFloatArray

gets the inverseMass of the points of the underlying N particle
object.'''
        pass

    def setMaxSelfCollisionIterations(self, it): 
        '''setMaxSelfCollisionIterations(self, it)
Arguments:
	[in]	it = int

Sets the number of iterations the solver will perform for self
collisions on this object.'''
        pass

    def setDragAndLift(self, drag, lift): 
        '''setDragAndLift(self, drag, lift)
Arguments:
	[in]	drag = float
	[in]	lift = float

Sets the drag and lift values for the cloth'''
        pass

    def setSelfCollisionSoftness(self, softness): 
        '''setSelfCollisionSoftness(self, softness)
Arguments:
	[in]	softness = float

This allows one to lower the repulsive force of self collisions
such that some interpenetration within the collide width is
allowed. This can in some cases reduce jitter due to self collision
with low selfCollideIterations. In general its use should be
avoided, however.'''
        pass

    def setBounce(self, bounce): 
        '''setBounce(self, bounce)
Arguments:
	[in]	bounce = float

sets the bounce on a per point basis in this mesh'''
        pass

    def setFriction(self, friction): 
        '''setFriction(self, friction)
Arguments:
	[in]	friction = float

sets the friction on a per point basis for this mesh'''
        pass

    def getThickness(self, radius): 
        '''getThickness(self, radius)
Arguments:
	[out]	radius = MFloatArray

gets the radii of the points of the underlying N particle
object.'''
        pass

    def setLiquidRadiusScale(self, liquidRadiusScale): 
        '''setLiquidRadiusScale(self, liquidRadiusScale)
Arguments:
	[in]	liquidRadiusScale = float

sets the liquidRadiusScale for every point in this mesh'''
        pass

    def setSurfaceTension(self, surfaceTension): 
        '''setSurfaceTension(self, surfaceTension)
Arguments:
	[in]	surfaceTension = float

sets the surfaceTension on a per point basis in this mesh'''
        pass

    def setMaxIterations(self, it): 
        '''setMaxIterations(self, it)
Arguments:
	[in]	it = int

Sets the number of iterations the solver will perform on various
dynamic properties like drag, damping, stretch and bend. Higher
iterations take longer, and the primary use of this attribute is to
keep things from locking up should high iteration values be
requested.'''
        pass

    def setDisableGravity(self, b): 
        '''setDisableGravity(self, b)
Arguments:
	[in]	b = bool

Sets whether gravity will affect this object'''
        pass

class MnRigid:
    '''Class for wrapping N cloth objects.'''
    def __init__(self):
        pass


    def getPositions(self, positions): 
        '''getPositions(self, positions)
Arguments:
	[out]	positions = MFloatPointArray

gets the positions of the points of the underlying N Object.'''
        pass

    def setBounce(self, bounce): 
        '''setBounce(self, bounce)
Arguments:
	[in]	bounce = float

sets the bounce on a per point basis in this mesh'''
        pass

    def getBounce(self, bounce): 
        '''getBounce(self, bounce)
Arguments:
	[out]	bounce = MFloatArray

gets the bounce at each point of the underlying N rigid
object.'''
        pass

    def getFriction(self, friction): 
        '''getFriction(self, friction)
Arguments:
	[out]	friction = MFloatArray

gets the friction at each point of the underlying N rigid
object.'''
        pass

    def getVelocities(self, velocities): 
        '''getVelocities(self, velocities)
Arguments:
	[out]	velocities = MFloatPointArray

gets the velocities of the points of the underlying N cloth
object.'''
        pass

    def setPositions(self, positions, startFrame): 
        '''setPositions(self, positions, startFrame)
Arguments:
	[in]	positions = MFloatPointArray
	[in]	startFrame = bool

Sets the positions of the vertices of the underlying N cloth
object'''
        pass

    def setThickness(self, radius): 
        '''setThickness(self, radius)
Arguments:
	[in]	radius = float

sets a radius (thickness) on a per point basis for the mesh for
collision purposes. The bigger the radius, the more easily things
collide.'''
        pass

    def setVelocities(self, velocities): 
        '''setVelocities(self, velocities)
Arguments:
	[in]	velocities = MFloatPointArray

Sets the velocities of the vertices of the underlying Ncloth
object'''
        pass

    def setFriction(self, friction): 
        '''setFriction(self, friction)
Arguments:
	[in]	friction = float

sets the friction on a per point basis for this mesh'''
        pass

    def getInverseMass(self, inverseMass): 
        '''getInverseMass(self, inverseMass)
Arguments:
	[out]	inverseMass = MFloatArray

gets the inverseMass at each point of the underlying N rigid
object.'''
        pass

    def createNRigid(self): 
        '''createNRigid(self)
Creates the underlying Maya TnRigid and sets this class to wrap
it.'''
        pass

    def getThickness(self, radius): 
        '''getThickness(self, radius)
Arguments:
	[out]	radius = MFloatArray

gets the thickness at each point of the underlying N rigid
object.'''
        pass

    def getNumVertices(self, numVerts): 
        '''getNumVertices(self, numVerts)
Arguments:
	[out]	numVerts = int

Returns the number of vertices in the underlying nRigid'''
        pass

    def setCollisionFlags(self, vertToVert, edgeToEdge, faceToFace): 
        '''setCollisionFlags(self, vertToVert, edgeToEdge, faceToFace)
Arguments:
	[in]	vertToVert = bool
	[in]	edgeToEdge = bool
	[in]	faceToFace = bool

Sets how (or if) this object will collide with other
objects.'''
        pass

    def setTopology(self, numFaces, numVertsPerFace, faces, numEdges, edges): 
        '''setTopology(self, numFaces, numVertsPerFace, faces, numEdges, edges)
Arguments:
	[in]	numFaces = int
	[in]	numVertsPerFace = int
	[in]	faces = int
	[in]	numEdges = int
	[in]	edges = int

sets the topology of the underlying N Object. Before calling
other methods, this must be the first method you call once the
cloth object is created.'''
        pass

class MnSolver:
    '''Class for wrapping N solver objects.'''
    def __init__(self):
        pass


    def setGravity(self, grav): 
        '''setGravity(self, grav)
Arguments:
	[in]	grav = float

Sets the gravity magnitude for the objects being solved. Note
the the objects should already be added to the solver when applying
gravity'''
        pass

    def setWindNoiseIntensity(self, noise): 
        '''setWindNoiseIntensity(self, noise)
Arguments:
	[in]	noise = float

Sets the wind noise intensity for the underlying Maya solver
object.'''
        pass

    def addNObject(self, obj): 
        '''addNObject(self, obj)
Arguments:
	[in]	obj = MnObject

Assign the nucleus object to be solved by this solver.'''
        pass

    def setSubsteps(self, substeps): 
        '''setSubsteps(self, substeps)
Arguments:
	[in]	substeps = int

Set the number of substeps used by the solver'''
        pass

    def setAirDensity(self, dens): 
        '''setAirDensity(self, dens)
Arguments:
	[in]	dens = float

Sets the air Density for the solver'''
        pass

    def setGravityDir(self, gravX, gravY, gravZ): 
        '''setGravityDir(self, gravX, gravY, gravZ)
Arguments:
	[in]	gravX = float
	[in]	gravY = float
	[in]	gravZ = float

Sets the gravity direction for the underlying Maya solver
object.'''
        pass

    def removeAllCollisions(self): 
        '''removeAllCollisions(self)
Remove the collisions between all the objects assigned to the
Maya solver object.'''
        pass

    def removeNObject(self, obj): 
        '''removeNObject(self, obj)
Arguments:
	[in]	obj = MnObject

Remove the nucleus object from being solved by this solver.'''
        pass

    def makeAllCollide(self): 
        '''makeAllCollide(self)
Allow all the objects assigned to the Maya solver object to
collide.'''
        pass

    def setDisabled(self, disabled): 
        '''setDisabled(self, disabled)
Arguments:
	[in]	disabled = bool

Disables the solver - or re-enables it again'''
        pass

    def solve(self, solveTime): 
        '''solve(self, solveTime)
Arguments:
	[in]	solveTime = float

Solve from the last eval time until the specified time (in
seconds).'''
        pass

    def createNSolver(self): 
        '''createNSolver(self)
Creates the underlying Maya solver object and sets this class to
wrap it.'''
        pass

    def setWindSpeed(self, speed): 
        '''setWindSpeed(self, speed)
Arguments:
	[in]	speed = float

Sets the wind magnitude for the underlying Maya solver
object.'''
        pass

    def setWindDir(self, windX, windY, windZ): 
        '''setWindDir(self, windX, windY, windZ)
Arguments:
	[in]	windX = float
	[in]	windY = float
	[in]	windZ = float

Sets the wind direction for the underlying Maya solver
object.'''
        pass

    def setMaxIterations(self, maxIter): 
        '''setMaxIterations(self, maxIter)
Arguments:
	[in]	maxIter = int

Set the max number of collision iterations used by the
solver'''
        pass

    def setStartTime(self, startTime): 
        '''setStartTime(self, startTime)
Arguments:
	[in]	startTime = float

Sets the start Time in seconds for the solver'''
        pass

class MDynamicsUtil:
    '''Utility class for Maya dynamics.'''
    def __init__(self):
        pass


    def evalDynamics2dTexture(self, node, texAttr, uCoords, vCoords, resultColors, resultAlphas): 
        '''evalDynamics2dTexture(self, node, texAttr, uCoords, vCoords, resultColors, resultAlphas)
Arguments:
	[in]	node = MObject
	[in]	texAttr = MObject
	[in]	uCoords = MDoubleArray
	[in]	vCoords = MDoubleArray
	[out]	resultColors = MVectorArray
	[out]	resultAlphas = MDoubleArray

If a supported 2d texture (see  hasValidDynamics2dTexture() 
method documentation) is connected to the specified attribute, this
method can be called to evaluate that texture at a number of (u,v)
texture coordinate values.'''
        pass

    def hasValidDynamics2dTexture(self, node, texAttr): 
        '''hasValidDynamics2dTexture(self, node, texAttr) -> bool
Returns: Returns:
true if the node connected to the specified attribute is a
texture that can be evaluated using the evalDynamics2dTexture()
method, false otherwise.

Arguments:
	[in]	node = MObject
	[in]	texAttr = MObject

Certain aspects of Maya's dynamics can be textured using 2d
textures. For example, surface particle emitters can use a 2d
texture to modulate the emission rate over the surface. For these
purposes, only a subset of Maya's textures are supported, namely
the default 2d textures (bulge, checker, cloth, file, fluid texture
2d, fractal, grid, mountain, movie, noise, ocean, ramp, water). No
other nodes are supported. This method takes an attribute and
determines if there is a supported texture connected to it. If the
texture is supported, then the  evalDynamics2dTexture() 
method can be called to evaluate the texture at various (u,v)
coordinate values.'''
        pass

class MDynSweptLine:
    '''Class for evaluating curve segments as lines over time.'''
    def __init__(self):
        pass


    def tangent(self, t): 
        '''tangent(self, t) -> MVector
Returns: Returns:
A normalized vector

Arguments:
	[in]	t = double

Given a parametric time specified by 't', returns normalized
tangent of the line.'''
        pass

    def length(self, t): 
        '''length(self, t) -> double
Returns: Returns:
Total line length

Arguments:
	[in]	t = double

Given a parametric time specified by 't', returns the total
length of the line.'''
        pass

    def vertex(self, vertexId, t): 
        '''vertex(self, vertexId, t) -> MVector
Returns: Returns:
The vertex position

Arguments:
	[in]	vertexId = int
	[in]	t = double

Return the vertex requested by id, at the parametric time
value.'''
        pass

    def normal(self, x, y, z, t): 
        '''normal(self, x, y, z, t) -> MVector
Returns: Returns:
A normalized vector

Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	t = double

Given a parametric time specified by 't' and a vector, returns a
normalized vector perpendicular to the tangent, and rotated into
the plane defined by the tangent and vector argument.'''
        pass

class MDynSweptTriangle:
    '''Class for evaluating surfaces as triangles over time.'''
    def __init__(self):
        pass


    def area(self): 
        '''area(self) -> double

This method returns the area.'''
        pass

    def vertex(self, vertexId, t): 
        '''vertex(self, vertexId, t) -> MVector
Returns: Returns:
The vertex position.

Arguments:
	[in]	vertexId = int
	[in]	t = double

Return the vertex requested by id, at the parametric time
value.'''
        pass

    def normalToPoint(self, x, y, z, t): 
        '''normalToPoint(self, x, y, z, t) -> MVector
Returns: Returns:
A normalized vector

Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	t = double

Given a point, returns the normal of the triangle in the
direction towards the point. Determines which side of the triangle
to return the normal.'''
        pass

    def uvPoint(self, vertexId): 
        '''uvPoint(self, vertexId) -> MVector
Returns: Returns:
A vector. The u and v values are stored in the first two
coordinates. The third coordinate is not meaningful.

Arguments:
	[in]	vertexId = int

Given a vertex id, this method returns the UV point for the
vertex as a  MVector .'''
        pass

    def normal(self, t): 
        '''normal(self, t) -> MVector
Returns: Returns:
A normalized vector

Arguments:
	[in]	t = double

Given a parametric time specified by 't', returns the normal of
the triangle.'''
        pass

class MFnAirField:
    '''Function set for Air Fields.'''
    def __init__(self):
        pass


    def direction(self): 
        '''direction(self) -> MVector
Returns: Returns:
A vector representing direction.

Returns the direction the air is blowing.'''
        pass

    def setInheritRotation(self, enable): 
        '''setInheritRotation(self, enable)
Arguments:
	[in]	enable = bool

Enables the air field to undergo rotations and effect the
direction that the air field points.'''
        pass

    def componentOnly(self): 
        '''componentOnly(self) -> bool
Returns: Returns:


true Force applied only in direction of attributes.
false Force applied to match velocities.

Returns true if the air field will apply force only in the
direction specified by the combination of its direction, speed, and
inherit velocity attributes. Returns false if the force is made to
effect the object's velocity to match the air field's velocity.'''
        pass

    def setDirection(self, airDirection): 
        '''setDirection(self, airDirection)
Arguments:
	[in]	airDirection = MVector

Sets the direction vector for the air to blow.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setSpread(self, value): 
        '''setSpread(self, value)
Arguments:
	[in]	value = double

Sets the value representing an angle which objects are affected
by the air fields direction setting. This value is taken into
account when the Enable Spread attribute is turned on.'''
        pass

    def inheritVelocity(self): 
        '''inheritVelocity(self) -> double
Returns: Returns:
A value from 0 to 1 representing the amount of velocity
added.

Returns the amount of the moving air field's velocity that is
added to the direction and magnitude of the wind.'''
        pass

    def setSpeed(self, value): 
        '''setSpeed(self, value)
Arguments:
	[in]	value = double

Sets the control setting on how quickly the objects match the
velocity of the air field.'''
        pass

    def spread(self): 
        '''spread(self) -> double
Returns: Returns:


A value from 0 to 1 representing an angle.
A value of 0 effects objects only exactly in front of the
direction vector.
A value of 1 effects objects in front by 180 degrees along the
direction vector.

Returns a value that represents an angle which objects are
affected by the air fields direction setting. This value is taken
into account when the Enable Spread attribute is turned on.'''
        pass

    def enableSpread(self): 
        '''enableSpread(self) -> bool
Returns: Returns:


true Objects are affected in the area of the spread
angle.
false Objects are affected by the max distance
setting.

Returns true if the air field is using the spread angle to
define the influence of the air field.'''
        pass

    def setInheritVelocity(self, velocity): 
        '''setInheritVelocity(self, velocity)
Arguments:
	[in]	velocity = double

Sets the amount of the moving air field's velocity that is added
to the direction and magnitude of the wind.'''
        pass

    def inheritRotation(self): 
        '''inheritRotation(self) -> bool
Returns: Returns:


true Rotations will change the direction the air field
points.
false Rotations do not change the air field
direction.

Returns true if the air field is rotating or parented to a
rotating object, and will undergo that same rotation.'''
        pass

    def setComponentOnly(self, enable): 
        '''setComponentOnly(self, enable)
Arguments:
	[in]	enable = bool

Enables the air field to apply force specified as a combination
of its direction, speed, and inherit veloicty attributes.'''
        pass

    def speed(self): 
        '''speed(self) -> double
Returns: Returns:
The value of the speed setting.

Returns the control setting on how quickly objects match the
velocity of the air field.'''
        pass

    def setEnableSpread(self, enable): 
        '''setEnableSpread(self, enable)
Arguments:
	[in]	enable = bool

Enables the air field to influence objects based on the spread
angle setting.'''
        pass

class MFnDragField:
    '''Function set for Drag Fields.'''
    def __init__(self):
        pass


    def useDirection(self): 
        '''useDirection(self) -> bool
Returns: Returns:


true Use the direction setting to determine the braking
force.
false Use the objects velocity to determine the braking
force.

Returns true if the braking force is exerted only against the
component of the object's velocity that lies along the direction of
the drag force.'''
        pass

    def direction(self): 
        '''direction(self) -> MVector
Returns: Returns:
A vector representing direction.

Returns the direction of the drag force's influence along the x,
y, and z axes. You must have the Use Direction setting turned on
for this attribute to take effect.'''
        pass

    def setUseDirection(self, enable): 
        '''setUseDirection(self, enable)
Arguments:
	[in]	enable = bool

Enables the braking force to be exerted only against the
component of the object's velocity that lies along the direction
setting of the drag force.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setDirection(self, dragDirection): 
        '''setDirection(self, dragDirection)
Arguments:
	[in]	dragDirection = MVector

Sets the direction of the drag force's influence along the x, y,
and z axes. You must have the Use Direction setting turned on for
this attribute to take effect.'''
        pass

class MFnDynSweptGeometryData:
    '''Swept Geometry function set for dependency node data.'''
    def __init__(self):
        pass


    def triangleCount(self): 
        '''triangleCount(self) -> int
Returns: Returns:
Number of triangles

Return the number of triangles contained in the data.'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: Returns:
A handle to the new swept geometry data object

This method create a new swept geometry data object for use with
the dependency graph.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def lineCount(self): 
        '''lineCount(self) -> int
Returns: Returns:
Number of line segments

Return the number of line segments contained in the data.'''
        pass

    def sweptTriangle(self, index): 
        '''sweptTriangle(self, index) -> MDynSweptTriangle
Returns: Returns:
A const reference to the MDynSweptTriangle

Arguments:
	[in]	index = int

Return data for a swept triangle.'''
        pass

    def sweptLine(self, index): 
        '''sweptLine(self, index) -> MDynSweptLine
Returns: Returns:
A const reference to the MDynSweptLine

Arguments:
	[in]	index = int

Return data for a swept line.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnField:
    '''Function set for Dynamic Fields.'''
    def __init__(self):
        pass


    def isFalloffCurveConstantOne(self): 
        '''isFalloffCurveConstantOne(self) -> bool
Returns: Returns:
If falloff curve always returns a constant one

Returns true if falloffCurve is a constant one (default) or
false if not.'''
        pass

    def useMaxDistance(self): 
        '''useMaxDistance(self) -> bool
Returns: Returns:


true Field uses the maximum distance setting.
false Field ignores the maximum distance setting.

Returns true if the field will use the maximum distance setting
to determine the area of influence.'''
        pass

    def attenuation(self): 
        '''attenuation(self) -> double
Returns: Returns:


A positive value representing the exponent for rate of
change.
A value of 0 and the force remains constant over distance.

Returns the rate of change where the strength of the field
changes as the distance between the field and the affected object
increases.'''
        pass

    def setAttenuation(self, atten): 
        '''setAttenuation(self, atten)
Arguments:
	[in]	atten = double

Sets the rate of change where the strength of the field changes
as the distance between the field and the affected object
increases.'''
        pass

    def maxDistance(self): 
        '''maxDistance(self) -> double
Returns: Returns:
A value representing distance in internal linear units.

Returns the maximum distance from the field at which the force
of the field is exerted. The Use Max Distance setting must be
turned on for maximum distance to take effect. The maximum distance
is scaled by the falloff curve's non-zero range.'''
        pass

    def perVertex(self): 
        '''perVertex(self) -> bool
Returns: Returns:


true Force is applied to each individual point.
false Force is applied from the geometric center.

Returns true if the field exerts its force on each individual
point (cv, particle, vertex) equally. Returns false if the force is
exerted only from the geometric center of the object or set of
points.'''
        pass

    def setPerVertex(self, enable): 
        '''setPerVertex(self, enable)
Arguments:
	[in]	enable = bool

Enables the field to exert its force on each individual point
(cv, particle, vertex) equally. Otherwise, the force is exerted
only from the geometric center of the object or set of points.'''
        pass

    def magnitude(self): 
        '''magnitude(self) -> double
Returns: Returns:
A value representing the strength of the field.

Returns the strength of the field.'''
        pass

    def setMagnitude(self, mag): 
        '''setMagnitude(self, mag)
Arguments:
	[in]	mag = double

Sets the strength of the field.'''
        pass

    def falloffCurve(self, param): 
        '''falloffCurve(self, param) -> double
Returns: Returns:
The falloff value given the param.

Arguments:
	[in]	param = double

Returns falloff given the param in [0,1]. This is enabled if the
use the maximum distance is enabled.'''
        pass

    def setMaxDistance(self, dist): 
        '''setMaxDistance(self, dist)
Arguments:
	[in]	dist = double

Sets the maximum distance from the field at which the force of
the field is exerted. The Use Max Distance setting must be turned
on for maximum distance to take effect.'''
        pass

    def getForceAtPoint(self, point, velocity, mass, deltaTime, force): 
        '''getForceAtPoint(self, point, velocity, mass, deltaTime, force)
Arguments:
	[in]	point = MVectorArray
	[in]	velocity = MVectorArray
	[in]	mass = MDoubleArray
	[out]	force = MVectorArray
	[in]	deltaTime = double

Compute the force of a field on an array of points, given their
position, velocity, and mass. Note that only the Air and Vortex
fields require a time increment to compute forces, all other fields
will igonore this argument.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setUseMaxDistance(self, enable): 
        '''setUseMaxDistance(self, enable)
Arguments:
	[in]	enable = bool

Enables the field to use the maximum distance setting to
determine the area of influence.'''
        pass

class MFnFluid:
    '''Fluid node function set.'''
    def __init__(self):
        pass


    def setTemperatureMode(self, method, gradient): 
        '''setTemperatureMode(self, method, gradient)
Arguments:
	[in]	method = MFnFluid.FluidMethod
	[in]	gradient = MFnFluid.FluidGradient

Set the modes by which the temperature values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def setColorMode(self, method): 
        '''setColorMode(self, method)
Arguments:
	[in]	method = MFnFluid.ColorMethod

Set the modes by which the color values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def toGridIndex(self, objectSpacePoint, gridCoords): 
        '''toGridIndex(self, objectSpacePoint, gridCoords) -> bool
Returns: Returns:
True if the point is inside the fluid, false otherwise

Arguments:
	[in]	objectSpacePoint = MPoint
	[out]	gridCoords = int3

For the given point in object space, get the grid indices of the
voxel that it happens to lie in. If the point is outside the fluid,
the method returns false, and the indices should not be used.'''
        pass

    def getFuelMode(self, method, gradient): 
        '''getFuelMode(self, method, gradient)
Arguments:
	[out]	method = MFnFluid.FluidMethod
	[out]	gradient = MFnFluid.FluidGradient

Get the modes by which the fuel values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def getForceAtPoint(self, point, velocity, mass, deltaTime, force): 
        '''getForceAtPoint(self, point, velocity, mass, deltaTime, force)
Arguments:
	[in]	point = MVectorArray
	[in]	velocity = MVectorArray
	[in]	mass = MDoubleArray
	[out]	force = MVectorArray
	[in]	deltaTime = double

Compute the force of a field on an array of points, given their
position, velocity, and mass. Note that only the Air and Vortex
fields require a time increment to compute forces, all other fields
will igonore this argument.'''
        pass

    def velocityGridSizes(self, xsize, ysize, zsize): 
        '''velocityGridSizes(self, xsize, ysize, zsize)
Arguments:
	[out]	xsize = int
	[out]	ysize = int
	[out]	zsize = int

Returns the number of elements in the velocity grids. X velocity
size = (x resolution+1 * y resolution * z resolution). Y velocity
size = (x resolution * y resolution+1 * z resolution). Z velocity
size = (x resolution * y resolution * z resolution+1).'''
        pass

    def getCoordinates(self, u, v, w): 
        '''getCoordinates(self, u, v, w)
Arguments:
	[out]	u = float
	[out]	v = float
	[out]	w = float

This method returns pointers to the storage for the uvw
coordinate data in the fluid. The size of these arrays can be
obtained using the "gridSize" call. The uvw values supply the 3D
texture mapping coordinates for each cell.'''
        pass

    def index(self, index, xres, yres, zres, xi, yi, zi): 
        '''index(self, index, xres, yres, zres, xi, yi, zi)
Arguments:
	[in]	index = int
	[in]	xres = int
	[in]	yres = int
	[in]	zres = int
	[out]	xi = int
	[out]	yi = int
	[out]	zi = int

This is a utility routine for finding the coordinates of a cell
given the index, and the X, Y and Z resolutions. This is intended
for use primarily with the velocity arrays, where the resolutions
are different for each array. The X velocity array is one bigger in
X, etc.'''
        pass

    def kNegYGradient(self):
        '''This is an enum of FluidGradient.
Description: Ramp the value from one to zero along the Y axis.
Value: 5'''
        pass

    def kConstant(self):
        '''This is an enum of FluidGradient.
Description: Value is set to one across the volume.
Value: 0'''
        pass

    def kNegXGradient(self):
        '''This is an enum of FluidGradient.
Description: Ramp the value from one to zero along the X axis.
Value: 4'''
        pass

    def kCenterGradient(self):
        '''This is an enum of FluidGradient.
Description: Ramps the value from one at the center to zero at the
edges.
Value: 7'''
        pass

    def kYGradient(self):
        '''This is an enum of FluidGradient.
Description: Ramp the value from zero to one along the Y axis.
Value: 2'''
        pass

    def kXGradient(self):
        '''This is an enum of FluidGradient.
Description: Ramp the value from zero to one along the X axis.
Value: 1'''
        pass

    def kZGradient(self):
        '''This is an enum of FluidGradient.
Description: Ramp the value from zero to one along the Z axis.
Value: 3'''
        pass

    def kNegZGradient(self):
        '''This is an enum of FluidGradient.
Description: Ramp the value from one to zero along the Z axis.
Value: 6'''
        pass

    class FluidGradient:
        '''Non-functional class.  Values for this enum:
        kNegYGradient
        kConstant
        kNegXGradient
        kCenterGradient
        kYGradient
        kXGradient
        kZGradient
        kNegZGradient
'''
        def __init__(self):
            pass

    def getVelocity(self, Xvel, Yvel, Zvel): 
        '''getVelocity(self, Xvel, Yvel, Zvel)
Arguments:
	[out]	Xvel = float
	[out]	Yvel = float
	[out]	Zvel = float

This method returns pointers to the storage for the velocity
data in the fluid. The size of these arrays can be obtained using
the "gridSize" call.'''
        pass

    def density(self): 
        '''density(self) -> float*
Returns: Returns:
Pointer to the density data of the grid

This method returns a pointer to the storage for the density
data in the fluid. The size of this array can be obtained using the
"gridSize" call.'''
        pass

    def getColorMode(self, method): 
        '''getColorMode(self, method)
Arguments:
	[out]	method = MFnFluid.ColorMethod

Get the modes by which the color values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def create3D(self, Xres, Yres, Zres, Xdim, Ydim, Zdim, parent): 
        '''create3D(self, Xres, Yres, Zres, Xdim, Ydim, Zdim, parent) -> MObject
Returns: Returns:


If parent is NULL then the transform for this fluid shape is
returned
If parent is a DAG object then the new fluid shape is
returned

Arguments:
	[in]	Xres = int
	[in]	Yres = int
	[in]	Zres = int
	[in]	Xdim = double
	[in]	Ydim = double
	[in]	Zdim = double
	[in]	parent = MObject

Creates a fluid object from the specified data and sets this
function set to operate on the new fluid object.'''
        pass

    def getFalloffMode(self, method): 
        '''getFalloffMode(self, method)
Arguments:
	[out]	method = MFnFluid.FalloffMethod

Get the modes by which the falloff values in the grid are
determined. If the falloff grid is enabled, its values must be set
by the user.'''
        pass

    def setFuelMode(self, method, gradient): 
        '''setFuelMode(self, method, gradient)
Arguments:
	[in]	method = MFnFluid.FluidMethod
	[in]	gradient = MFnFluid.FluidGradient

Set the modes by which the fuel values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation. The fuel value for a
cell can be thought of as the amount of fuel contained in the cell
that will be consumed during the simulation.'''
        pass

    def fuel(self): 
        '''fuel(self) -> float*
Returns: Returns:
Pointer to the fuel data of the grid

This method returns a pointer to the storage for the fuel data
in the fluid. The size of this array can be obtained using the
"gridSize" call.'''
        pass

    def setFalloffMode(self, method): 
        '''setFalloffMode(self, method)
Arguments:
	[in]	method = MFnFluid.FalloffMethod

Set the modes by which the shader falloff values in the grid are
determined. If the falloff grid is enabled, its values must be set
by the user.'''
        pass

    def setDensityMode(self, method, gradient): 
        '''setDensityMode(self, method, gradient)
Arguments:
	[in]	method = MFnFluid.FluidMethod
	[in]	gradient = MFnFluid.FluidGradient

Set the modes by which the density values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getTemperatureMode(self, method, gradient): 
        '''getTemperatureMode(self, method, gradient)
Arguments:
	[out]	method = MFnFluid.FluidMethod
	[out]	gradient = MFnFluid.FluidGradient

Get the modes by which the temperature values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def updateGrid(self): 
        '''updateGrid(self)
Tells the fluid shape that the contents of the fluid grid has
changed. It is necessary to call this routine after modifying
internal fluid data via a pointer recieved from any of the access
routines in this function set. Failure to call this will result in
the fluid not drawing with your changes.'''
        pass

    def gridSize(self): 
        '''gridSize(self) -> int
Returns: Returns:
The number of elements.

Returns the number of elements in the grid. This is equal to (x
resolution * y resolution * z resolution). This routine is provided
as a convenience to be used with the methods that give direct
access to the fluid data. This gives the upper bound on the arrays.
This size applies to all grids except for the 3 velocity grids.'''
        pass

    def kFixed(self):
        '''This is an enum of CoordinateMethod.
Description: Values are equal the object space coordinates.
Value: 0'''
        pass

    def kGrid(self):
        '''This is an enum of CoordinateMethod.
Description: Coordinate values will be moved using the current density
solver.
Value: 1'''
        pass

    class CoordinateMethod:
        '''Non-functional class.  Values for this enum:
        kFixed
        kGrid
'''
        def __init__(self):
            pass

    def falloff(self): 
        '''falloff(self) -> float*
Returns: Returns:
Pointer to the float data of the grid

This method returns a pointer to the storage for the falloff
data in the fluid. The size of this array can be obtained using the
"gridSize" call.'''
        pass

    def getDimensions(self, Xdim, Ydim, Zdim): 
        '''getDimensions(self, Xdim, Ydim, Zdim)
Arguments:
	[out]	Xdim = double
	[out]	Ydim = double
	[out]	Zdim = double

Gets the dimensions of the fluid. The dimensions give the object
space size of the fluid object in each direction.'''
        pass

    def getVelocityMode(self, method, gradient): 
        '''getVelocityMode(self, method, gradient)
Arguments:
	[out]	method = MFnFluid.FluidMethod
	[out]	gradient = MFnFluid.FluidGradient

Get the modes by which the velocity values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def kZero(self):
        '''This is an enum of FluidMethod.
Description: All values in grid are zero.
Value: 0'''
        pass

    def kStaticGrid(self):
        '''This is an enum of FluidMethod.
Description: Values in the grid are static.
Value: 1'''
        pass

    def kGradient(self):
        '''This is an enum of FluidMethod.
Description: Ramps the value based on the gradient setting.
Value: 3'''
        pass

    def kDynamicGrid(self):
        '''This is an enum of FluidMethod.
Description: Values in the grid come from a dynamic solver.
Value: 2'''
        pass

    class FluidMethod:
        '''Non-functional class.  Values for this enum:
        kZero
        kStaticGrid
        kGradient
        kDynamicGrid
'''
        def __init__(self):
            pass

    def setCoordinateMode(self, method): 
        '''setCoordinateMode(self, method)
Arguments:
	[in]	method = MFnFluid.CoordinateMethod

Set the modes by which the UVW coordinate values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def temperature(self): 
        '''temperature(self) -> float*
Returns: Returns:
Pointer to the temperature data of the grid

This method returns a pointer to the storage for the temperature
data in the fluid. The size of this array can be obtained using the
"gridSize" call.'''
        pass

    def kStaticColorGrid(self):
        '''This is an enum of ColorMethod.
Description: Values in the grid are static.
Value: 1'''
        pass

    def kDynamicColorGrid(self):
        '''This is an enum of ColorMethod.
Description: Values in the grid come from a dynamic solver.
Value: 2'''
        pass

    def kUseShadingColor(self):
        '''This is an enum of ColorMethod.
Description: Off, use shading color instead.
Value: 0'''
        pass

    class ColorMethod:
        '''Non-functional class.  Values for this enum:
        kStaticColorGrid
        kDynamicColorGrid
        kUseShadingColor
'''
        def __init__(self):
            pass

    def pressure(self): 
        '''pressure(self) -> float*
Returns: Returns:
Pointer to the pressure data of the grid

This method returns a pointer to the storage for the pressure
data in the fluid. The size of this array can be obtained using the
"gridSize" call. Note that the pressure data only exists if the
velocity method is kStaticGrid or kDynamicGrid'''
        pass

    def emitIntoArrays(self, val, x, y, z, density, heat, fuel, doColor, emitColor): 
        '''emitIntoArrays(self, val, x, y, z, density, heat, fuel, doColor, emitColor)
Arguments:
	[in]	val = float
	[in]	x = int
	[in]	y = int
	[in]	z = int
	[in]	density = float
	[in]	heat = float
	[in]	fuel = float
	[in]	doColor = bool
	[in]	emitColor = MColor

Use this method to add density, heat, fuel, and/or color to a
particular voxel of a fluid.'''
        pass

    def kNoFalloffGrid(self):
        '''This is an enum of FalloffMethod.
Description: No falloff grid should be defined.
Value: 0'''
        pass

    def kStaticFalloffGrid(self):
        '''This is an enum of FalloffMethod.
Description: Values in the falloff grid are static.
Value: 1'''
        pass

    class FalloffMethod:
        '''Non-functional class.  Values for this enum:
        kNoFalloffGrid
        kStaticFalloffGrid
'''
        def __init__(self):
            pass

    def create2D(self, Xres, Yres, Xdim, Ydim, parent): 
        '''create2D(self, Xres, Yres, Xdim, Ydim, parent) -> MObject
Returns: Returns:


If parent is NULL then the transform for this fluid shape is
returned
If parent is a DAG object then the new fluid shape is
returned

Arguments:
	[in]	Xres = int
	[in]	Yres = int
	[in]	Xdim = double
	[in]	Ydim = double
	[in]	parent = MObject

Creates a fluid object from the specified data and sets this
function set to operate on the new fluid object.'''
        pass

    def voxelCenterPosition(self, xi, yi, zi, objectSpacePoint): 
        '''voxelCenterPosition(self, xi, yi, zi, objectSpacePoint)
Arguments:
	[in]	xi = int
	[in]	yi = int
	[in]	zi = int
	[out]	objectSpacePoint = MPoint

For the given voxel, get the location of the center in object
space. If the voxel indices are not valid, the point may not be set
to a valid point'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getCoordinateMode(self, method): 
        '''getCoordinateMode(self, method)
Arguments:
	[out]	method = MFnFluid.CoordinateMethod

Get the modes by which the UVW coordinates values in the grid
are determined. The values may be set by the user in various ways,
or they may be computed as part of a simulation.'''
        pass

    def getDensityMode(self, method, gradient): 
        '''getDensityMode(self, method, gradient)
Arguments:
	[out]	method = MFnFluid.FluidMethod
	[out]	gradient = MFnFluid.FluidGradient

Get the modes by which the density values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def getColors(self, r, g, b): 
        '''getColors(self, r, g, b)
Arguments:
	[out]	r = float
	[out]	g = float
	[out]	b = float

This method returns pointers to the storage for the color data
in the fluid. The size of these arrays can be obtained using the
"gridSize" call.'''
        pass

    def setVelocityMode(self, method, gradient): 
        '''setVelocityMode(self, method, gradient)
Arguments:
	[in]	method = MFnFluid.FluidMethod
	[in]	gradient = MFnFluid.FluidGradient

Set the modes by which the velocity values in the grid are
determined. The values may be set by the user in various ways, or
they may be computed as part of a simulation.'''
        pass

    def setSize(self, Xres, Yres, Xdim, Ydim, resample): 
        '''setSize(self, Xres, Yres, Xdim, Ydim, resample)
Arguments:
	[in]	Xres = int
	[in]	Yres = int
	[in]	Xdim = double
	[in]	Ydim = double
	[in]	resample = bool

Sets the size and resolution of the grid. The resolution
parameters control the number of cells in the fluid grid and the
dimension parameters set the size of the fluid shape in object
space.'''
        pass

    def getResolution(self, Xres, Yres): 
        '''getResolution(self, Xres, Yres)
Arguments:
	[out]	Xres = int
	[out]	Yres = int

Gets the resolution of the fluid. The resolution gives the
number of cells in the fluid grid in each direction.'''
        pass

class MFnGravityField:
    '''Function set for Gravity Fields.'''
    def __init__(self):
        pass


    def direction(self): 
        '''direction(self) -> MVector
Returns: Returns:
A vector representing direction.

Returns the direction of the gravitational force.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setDirection(self, gravityDirection): 
        '''setDirection(self, gravityDirection)
Arguments:
	[in]	gravityDirection = MVector

Sets the direction vector of the gravitational force.'''
        pass

class MFnInstancer:
    '''Particle Instancer object access class.'''
    def __init__(self):
        pass


    def allInstances(self, paths, matrices, particlePathStartIndices, pathIndices): 
        '''allInstances(self, paths, matrices, particlePathStartIndices, pathIndices)
Arguments:
	[out]	paths = MDagPathArray
	[out]	matrices = MMatrixArray
	[out]	particlePathStartIndices = MIntArray
	[out]	pathIndices = MIntArray

Returns information about all instances generated by a
particular particle instancer node. Since many particles will
typically instance similar sets of paths, the information is
returned in a compact representation. An array of paths is
returned, representing the unique set of paths that are instanced
by any particle in the system. For each particle, the routine
returns a set of indices into this path array to illustrate the
paths instanced at that particle. The index arrays for all
particles are concatenated together, so a "start index" array is
used to indicate which is the first entry in the index array for
each particle. For each particle, the routine also returns the
transformation matrix applied to that particle's instanced paths to
generate the final particle instance transformations.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def particleCount(self): 
        '''particleCount(self) -> int

Returns the number of particles feeding the active instancer'''
        pass

    def instancesForParticle(self, p, paths, instancerMatrix): 
        '''instancesForParticle(self, p, paths, instancerMatrix) -> int
Returns: Returns:
The number of visible paths instanced for the given particle.
It is possible for no paths to be instanced for a particular
particle. Note that in order to use this method, the MDagPath must be
used in the constructor.

Arguments:
	[in]	p = int
	[out]	paths = MDagPathArray
	[out]	instancerMatrix = MMatrix

Returns the DAG paths and instancer matrix for all instances
generated by a specified particle'''
        pass

class MFnNewtonField:
    '''Function set for Newton Fields.'''
    def __init__(self):
        pass


    def setMinDistance(self, distance): 
        '''setMinDistance(self, distance)
Arguments:
	[in]	distance = double

Sets the minimum distance from the newton field at which the
force of the field is exerted.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def minDistance(self): 
        '''minDistance(self) -> double
Returns: Returns:
A value representing distance in internal linear units.

Returns the minimum distance from the newton field at which the
force of the field is exerted.'''
        pass

class MFnNIdData:
    '''function set for nId object data'''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getObjectPtr(self, ptr): 
        '''getObjectPtr(self, ptr)
Arguments:
	[out]	ptr = MnObject

Get the nObject pointer'''
        pass

    def create(self): 
        '''create(self) -> MObject

Creates an underlying Maya nId data object and return it as an
 MObject'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnNObjectData:
    '''function set for nCloth object data'''
    def __init__(self):
        pass


    def getCollide(self, collide): 
        '''getCollide(self, collide)
Arguments:
	[out]	collide = bool

Get wether the nObject is allowed to participate in
collisions'''
        pass

    def setCached(self, cached): 
        '''setCached(self, cached)
Arguments:
	[in]	cached = bool

Set wether the nObject is cached.'''
        pass

    def create(self): 
        '''create(self) -> MObject

Creates an underlying Maya N data object and return it as an
 MObject'''
        pass

    def setObjectPtr(self, ptr): 
        '''setObjectPtr(self, ptr)
Arguments:
	[in]	ptr = MnParticle

Set the nParticle pointer'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getObjectPtr(self, ptr): 
        '''getObjectPtr(self, ptr)
Arguments:
	[out]	ptr = MnParticle

Get the nObject pointer for an nParticle'''
        pass

    def getCached(self, cached): 
        '''getCached(self, cached)
Arguments:
	[out]	cached = bool

Get wether the nObject is cached.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnParticleSystem:
    '''Class for obtaining information about a particle system.Use this chart to determine which methods to call based on the
render type of the particle object:'''
    def __init__(self):
        pass


    def radius1(self, radii): 
        '''radius1(self, radii)
Arguments:
	[in]	radii = MDoubleArray

'''
        pass

    def radius0(self, radii): 
        '''radius0(self, radii)
Arguments:
	[in]	radii = MDoubleArray

'''
        pass

    def hasEmission(self): 
        '''hasEmission(self) -> bool

'''
        pass

    def disableCloudAxis(self): 
        '''disableCloudAxis(self) -> bool

'''
        pass

    def renderType(self): 
        '''renderType(self) -> MFnParticleSystem.RenderType

'''
        pass

    def radius(self, radii): 
        '''radius(self, radii)
Arguments:
	[in]	radii = MDoubleArray

'''
        pass

    def threshold(self): 
        '''threshold(self) -> double

'''
        pass

    def acceleration(self, array): 
        '''acceleration(self, array)
Arguments:
	[out]	array = MVectorArray

To return acceleration array for all particles.'''
        pass

    def position(self, positions): 
        '''position(self, positions)
Arguments:
	[in]	positions = MVectorArray

'''
        pass

    def hasLifespan(self): 
        '''hasLifespan(self) -> bool

'''
        pass

    def isPerParticleDoubleAttribute(self, attrName): 
        '''isPerParticleDoubleAttribute(self, attrName) -> bool

Arguments:
	[in]	attrName = MString

To check if the input attribute is a per particle double
attribute.'''
        pass

    def create(self, parentMObj): 
        '''create(self, parentMObj) -> MObject
Returns: Returns:
The newly created particleShape

Arguments:
	[in]	parentMObj = MObject

To create a new particleShape. If the parent is not specified, a
new transform will be created as the parent.'''
        pass

    def position1(self, positions): 
        '''position1(self, positions)
Arguments:
	[in]	positions = MVectorArray

'''
        pass

    def rgb(self, colors): 
        '''rgb(self, colors)
Arguments:
	[in]	colors = MVectorArray

'''
        pass

    def castsShadows(self): 
        '''castsShadows(self) -> bool

'''
        pass

    def kMultiPoint(self):
        '''This is an enum of RenderType.
Description: 
Value: 3'''
        pass

    def kMultiStreak(self):
        '''This is an enum of RenderType.
Description: 
Value: 4'''
        pass

    def kPoints(self):
        '''This is an enum of RenderType.
Description: 
Value: 6'''
        pass

    def kNumeric(self):
        '''This is an enum of RenderType.
Description: 
Value: 5'''
        pass

    def kStreak(self):
        '''This is an enum of RenderType.
Description: 
Value: 9'''
        pass

    def kSpheres(self):
        '''This is an enum of RenderType.
Description: 
Value: 7'''
        pass

    def kCloud(self):
        '''This is an enum of RenderType.
Description: 
Value: 0'''
        pass

    def kBlobby(self):
        '''This is an enum of RenderType.
Description: 
Value: 2'''
        pass

    def kSprites(self):
        '''This is an enum of RenderType.
Description: 
Value: 8'''
        pass

    def kTube(self):
        '''This is an enum of RenderType.
Description: 
Value: 1'''
        pass

    class RenderType:
        '''Non-functional class.  Values for this enum:
        kMultiPoint
        kMultiStreak
        kPoints
        kNumeric
        kStreak
        kSpheres
        kCloud
        kBlobby
        kSprites
        kTube
'''
        def __init__(self):
            pass

    def hasOpacity(self): 
        '''hasOpacity(self) -> bool

'''
        pass

    def surfaceShading(self): 
        '''surfaceShading(self) -> double

'''
        pass

    def betterIllum(self): 
        '''betterIllum(self) -> bool

'''
        pass

    def primaryVisibility(self): 
        '''primaryVisibility(self) -> bool

'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def particleIds(self, ids): 
        '''particleIds(self, ids)
Arguments:
	[out]	ids = MIntArray

Return an array of particle identifiers at the start of the time
step. The array of particle id's is correlated with the other
per-particle arrays returned by this class, so ids[i] will be the
id for the particle with position position[i], velocity[i], etc.,
as long as all these arrays were retrieved for the same time
step.'''
        pass

    def opacity(self, opacities): 
        '''opacity(self, opacities)
Arguments:
	[in]	opacities = MDoubleArray

'''
        pass

    def deformedParticleShape(self): 
        '''deformedParticleShape(self) -> MObject
Returns: Returns:
The particle shape connecting to the output of the
deformer(s)

To get the deformed particleShape.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool

'''
        pass

    def setCount(self, count): 
        '''setCount(self, count)
Arguments:
	[in]	count = int

'''
        pass

    def emission(self, emissions): 
        '''emission(self, emissions)
Arguments:
	[in]	emissions = MVectorArray

'''
        pass

    def tailSize(self): 
        '''tailSize(self) -> double

'''
        pass

    def isPerParticleIntAttribute(self, attrName): 
        '''isPerParticleIntAttribute(self, attrName) -> bool

Arguments:
	[in]	attrName = MString

To check if the input attribute is a per particle integer
attribute.'''
        pass

    def visibleInRefractions(self): 
        '''visibleInRefractions(self) -> bool

'''
        pass

    def hasRgb(self): 
        '''hasRgb(self) -> bool

'''
        pass

    def particleName(self): 
        '''particleName(self) -> MString

'''
        pass

    def receiveShadows(self): 
        '''receiveShadows(self) -> bool

'''
        pass

    def getPerParticleAttribute(self, attrName, array): 
        '''getPerParticleAttribute(self, attrName, array) -> int
Returns: Returns:
The size of the returned double array

Arguments:
	[in]	attrName = MString
	[out]	array = MDoubleArray

To get the per particle double attribute of the given name'''
        pass

    def count(self): 
        '''count(self) -> int

'''
        pass

    def isPerParticleVectorAttribute(self, attrName): 
        '''isPerParticleVectorAttribute(self, attrName) -> bool

Arguments:
	[in]	attrName = MString

To check if the input attribute is a per particle vector
attribute.'''
        pass

    def visibleInReflections(self): 
        '''visibleInReflections(self) -> bool

'''
        pass

    def saveInitialState(self): 
        '''saveInitialState(self)
To reset the particle's current state as the initial state.'''
        pass

    def age(self, ages): 
        '''age(self, ages)
Arguments:
	[in]	ages = MDoubleArray

'''
        pass

    def isDeformedParticleShape(self): 
        '''isDeformedParticleShape(self) -> bool
Returns: Returns:
true particle shape is deformed, false
otherwise.

To return if this particle shape is deformed.'''
        pass

    def lifespan(self, lifespans): 
        '''lifespan(self, lifespans)
Arguments:
	[in]	lifespans = MDoubleArray

'''
        pass

    def emit(self, pArray, vArray): 
        '''emit(self, pArray, vArray)
Arguments:
	[in]	pArray = MPointArray
	[in]	vArray = MVectorArray

To add an array of new particles at the given positions with
their velocity values.'''
        pass

    def originalParticleShape(self): 
        '''originalParticleShape(self) -> MObject
Returns: Returns:
The particle shape connecting to the input of the
deformer(s)

To get the original particleShape.'''
        pass

    def mass(self, array): 
        '''mass(self, array)
Arguments:
	[out]	array = MDoubleArray

To return mass array for all particles.'''
        pass

    def setPerParticleAttribute(self, attrName, array): 
        '''setPerParticleAttribute(self, attrName, array)
Arguments:
	[in]	attrName = MString
	[in]	array = MDoubleArray

To set the per particle double attribute of the given name with
the given values.'''
        pass

    def velocity(self, array): 
        '''velocity(self, array)
Arguments:
	[out]	array = MVectorArray

To return velocity array for all particles.'''
        pass

    def evaluateDynamics(self, to, runupFromStart): 
        '''evaluateDynamics(self, to, runupFromStart)
Arguments:
	[in]	to = MTime
	[in]	runupFromStart = bool

'''
        pass

    def position0(self, positions): 
        '''position0(self, positions)
Arguments:
	[in]	positions = MVectorArray

'''
        pass

class MFnPfxGeometry:
    '''PfxGeometry node function set.'''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getLineData(self, doLines, doTwist, doWidth, doFlatness, doParameter, doColor, doIncandescence, doTransparency, worldSpace, mainLines, leafLines, flowerLines): 
        '''getLineData(self, doLines, doTwist, doWidth, doFlatness, doParameter, doColor, doIncandescence, doTransparency, worldSpace, mainLines, leafLines, flowerLines)
Arguments:
	[out]	mainLines = MRenderLineArray
	[out]	leafLines = MRenderLineArray
	[out]	flowerLines = MRenderLineArray
	[in]	doLines = bool
	[in]	doTwist = bool
	[in]	doWidth = bool
	[in]	doFlatness = bool
	[in]	doParameter = bool
	[in]	doColor = bool
	[in]	doIncandescence = bool
	[in]	doTransparency = bool
	[in]	worldSpace = bool

Get line data for the current output pfx tubes. The passed in
arrays will be filled with pointers to MrenderLine classes. If
there are no leaves or flowers then the passed in leafLine and
flowerLine arrays will be left empty. Arrays are generated for only
the specified attributes. This routine creates the memory for the
arrays that it computes. This memory can only be released using the
deleteArray method on the  MRenderLineArray 
class. DeleteArray should be called for the mainLine, leafLine, and
flowerLine variables when done. These variables wrap the returned
data and allow access but the  MRenderLineArray 
destructer does not delete this wrapped memory, so one must use
 MRenderLineArray::deleteArray() .
The  MRenderLine ,
 MVectorArray  and MDoubleArrays
returned from  MRenderLineArray 
will point to deleted memory after calling deleteArray, so be
careful to only call deleteArray when finished using the line
data(or copy the arrays first).'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getBoundingBox(self, min, max): 
        '''getBoundingBox(self, min, max)
Arguments:
	[out]	min = double
	[out]	max = double

Gets the bounding box of the specified geometry. The passed in
double arrays will be filled with minimum and maximum coordinates
of the geometry.'''
        pass

class MFnRadialField:
    '''Function set for Radial Fields.'''
    def __init__(self):
        pass


    def radialType(self): 
        '''radialType(self) -> double
Returns: Returns:


A value representing a type of radial field attenuation.
A value of 1 uses the magnitude, attenuation, and distance
settings from the field to determine the net force of the radial
field.
A value of 0 will use the ratio of the absolute distance and
the maximum distance setting.
A value between 0 and 1 will create a linear blend between the
two types.

Returns a type that controls the way the radial field is
attenuated.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setType(self, value): 
        '''setType(self, value)
Arguments:
	[in]	value = double

Sets a radial field type that controls the way the field is
attenuated.'''
        pass

class MFnTurbulenceField:
    '''Function set for Turbulence Fields.'''
    def __init__(self):
        pass


    def phase(self): 
        '''phase(self) -> double
Returns: Returns:
A value representing a noise generation parameter.

Returns the phase shift parameter that influences the direction
of the turbulence field disruption. Currently this returns the
phaseZ attribute, which was called simply phase in versions of Maya
prior to 3.0.'''
        pass

    def frequency(self): 
        '''frequency(self) -> double
Returns: Returns:
A value representing a noise generation parameter.

Returns the frequency parameter that generates irregularities in
the fields motion.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setPhase(self, value): 
        '''setPhase(self, value)
Arguments:
	[in]	value = double

Sets the phase shift parameter of the Perlin noise function used
by the turbulence field. Both positive and negative values are
legal and influence the direction of the disruption. Sets the
phaseZ parameter, which was called simply phase in versions of Maya
prior to 3.0.'''
        pass

    def setFrequency(self, value): 
        '''setFrequency(self, value)
Arguments:
	[in]	value = double

Sets the frequency parameter of the Perlin noise function used
by the turbulence field. Values are positive, with larger values
causing more frequent irregularities in the motion.'''
        pass

class MFnUniformField:
    '''Function set for Uniform Fields.'''
    def __init__(self):
        pass


    def direction(self): 
        '''direction(self) -> MVector
Returns: Returns:
A vector representing direction.

Returns the direction the uniform field pushes objects.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setDirection(self, uniformDirection): 
        '''setDirection(self, uniformDirection)
Arguments:
	[in]	uniformDirection = MVector

Sets the direction the uniform field pushes objects.'''
        pass

class MFnVolumeAxisField:
    '''Function set for VolumeAxis Fields.'''
    def __init__(self):
        pass


    def speedAlongAxis(self): 
        '''speedAlongAxis(self) -> double
Returns: Returns:
A double value representing the speed along axis.

Returns the alongAxis attribute of the field.'''
        pass

    def setTurbulenceSpeed(self, value): 
        '''setTurbulenceSpeed(self, value)
Arguments:
	[in]	value = double

Sets the turbulence speed attribute for the field force.'''
        pass

    def turbulenceFrequency(self): 
        '''turbulenceFrequency(self) -> MVector
Returns: Returns:
A vector representing frequency or scale of the
turbulence.

Returns the turbulenceFrequency attribute for the field
force.'''
        pass

    def setSpeedAwayFromAxis(self, speed): 
        '''setSpeedAwayFromAxis(self, speed)
Arguments:
	[in]	speed = double

Sets the speed away from axis attribute for the field force.'''
        pass

    def turbulenceOffset(self): 
        '''turbulenceOffset(self) -> MVector
Returns: Returns:
A vector representing an offset or translation of the
turbulence.

Returns the turbulenceOffset attribute for the field force.'''
        pass

    def setDirection(self, direction): 
        '''setDirection(self, direction)
Arguments:
	[in]	direction = MVector

Sets the direction attribute for the field force.'''
        pass

    def speedAwayFromCenter(self): 
        '''speedAwayFromCenter(self) -> double
Returns: Returns:
A double value representing the speed away from center.

Returns the awayFromCenter attribute of the field.'''
        pass

    def setTurbulenceFrequency(self, value): 
        '''setTurbulenceFrequency(self, value)
Arguments:
	[in]	value = MVector

Sets the turbulenceFrequency attribute for the field force.'''
        pass

    def detailTurbulence(self, value): 
        '''detailTurbulence(self, value)
Arguments:
	[in]	value = double

Sets the detailTurbulence attribute for the field force.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def invertAttenuation(self): 
        '''invertAttenuation(self) -> bool
Returns: Returns:


true Field is strongest close to volume outer
boundary.
false Field is strongest close to volume center.

Returns the value of the invertAttenuation attribute for the
field force.'''
        pass

    def setTurbulence(self, value): 
        '''setTurbulence(self, value)
Arguments:
	[in]	value = double

Sets the turbulence attribute for the field force.'''
        pass

    def setTurbulenceOffset(self, value): 
        '''setTurbulenceOffset(self, value)
Arguments:
	[in]	value = MVector

Sets the turbulenceOffset attribute for the field force.'''
        pass

    def direction(self): 
        '''direction(self) -> MVector
Returns: Returns:
A vector representing direction.

Returns the direction attribute for the field force.'''
        pass

    def setSpeedAwayFromCenter(self, speed): 
        '''setSpeedAwayFromCenter(self, speed)
Arguments:
	[in]	speed = double

Sets the speed away from center attribute for the field
force.'''
        pass

    def directionalSpeed(self): 
        '''directionalSpeed(self) -> double
Returns: Returns:
A double value representing the directional speed.

Returns the directionalSpeed attribute of the field.'''
        pass

    def setInvertAttenuation(self, enable): 
        '''setInvertAttenuation(self, enable)
Arguments:
	[in]	enable = bool

Enables the field will be stronger the closer to the edge of the
volume a point is.'''
        pass

    def turbulence(self): 
        '''turbulence(self) -> double
Returns: Returns:
A double value representing the turbulence intensity.

Returns the turbulence intensity of the field.'''
        pass

    def setSpeedAroundAxis(self, speed): 
        '''setSpeedAroundAxis(self, speed)
Arguments:
	[in]	speed = double

Sets the speed around axis attribute for the field force.'''
        pass

    def speedAroundAxis(self): 
        '''speedAroundAxis(self) -> double
Returns: Returns:
A double value representing the speed around axis.

Returns the aroundAxis attribute of the field.'''
        pass

    def setSpeedAlongAxis(self, speed): 
        '''setSpeedAlongAxis(self, speed)
Arguments:
	[in]	speed = double

Sets the speed along axis attribute for the field force.'''
        pass

    def turbulenceSpeed(self): 
        '''turbulenceSpeed(self) -> double
Returns: Returns:
A double value representing the turbulence speed.

Returns the rate of change of the turbulence over time.'''
        pass

    def setDirectionalSpeed(self, speed): 
        '''setDirectionalSpeed(self, speed)
Arguments:
	[in]	speed = double

Sets the directional speed attribute for the field force.'''
        pass

    def speedAwayFromAxis(self): 
        '''speedAwayFromAxis(self) -> double
Returns: Returns:
A double value representing the speed away from axis.

Returns the awayFromAxis attribute of the field.'''
        pass

class MFnVortexField:
    '''Function set for Vortex Fields.'''
    def __init__(self):
        pass


    def setAxis(self, axisVector): 
        '''setAxis(self, axisVector)
Arguments:
	[in]	axisVector = MVector

Sets the axis around which the vortex field exerts it's
force.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def axis(self): 
        '''axis(self) -> MVector
Returns: Returns:
A vector representing an axis.

Returns the axis around which the vortex field exerts it's
force.'''
        pass

class MHairSystem:
    '''Interface with Maya's Dynamic Hair System.'''
    def __init__(self):
        pass


    def unregisterCollisionSolverPreFrame(self): 
        '''unregisterCollisionSolverPreFrame(self)
De-register any user-defined pre-frame callback that might have
been registered via  MHairSystem::registerCollisionSolverPreFrame .
  Reprocessed example '''
        pass

    def setRegisteringCallableScript(self): 
        '''setRegisteringCallableScript(self)
'''
        pass

    def getCollisionObject(self, hairSystem, objects, logicalIndices): 
        '''getCollisionObject(self, hairSystem, objects, logicalIndices)
Arguments:
	[in]	hairSystem = MObject
	[out]	objects = MObjectArray
	[out]	logicalIndices = MIntArray

Returns all collision objects for the hair system.'''
        pass

    def registerCollisionSolverPreFrame(self, fnPtr): 
        '''registerCollisionSolverPreFrame(self, fnPtr)
Arguments:
	[in]	fnPtr = MHairSystemCollisionSolverPreFrameFnPtr

Register the user-supplied pre-frame method `fnPtr' with Maya.
This method will be invoked at the start of each frame.'''
        pass

    def registerCollisionSolverCollide(self, fnPtr): 
        '''registerCollisionSolverCollide(self, fnPtr)
Arguments:
	[in]	fnPtr = MHairSystemCollisionSolverCollideFnPtr

Register the user-supplied collision solver `fnPtr' with Maya.
This method will be invoked per-hair times the number of iterations
specified by the hairSystem node and the method can be used to
perfrom several functions:'''
        pass

    def getFollicle(self, hairSystem, follicles, logicalIndices): 
        '''getFollicle(self, hairSystem, follicles, logicalIndices)
Arguments:
	[in]	hairSystem = MObject
	[out]	follicles = MObjectArray
	[out]	logicalIndices = MIntArray

Returns all follicles for the hair system.'''
        pass

    def unregisterCollisionSolverCollide(self): 
        '''unregisterCollisionSolverCollide(self)
De-register any user-defined collision solver that might have
been registered via  registerCollisionSolverCollide() .
  Reprocessed example '''
        pass

    def registeringCallableScript(self): 
        '''registeringCallableScript(self) -> bool

'''
        pass

class MRenderLine:
    '''Class for accessing paint effects output curve data.'''
    def __init__(self):
        pass


    def getTransparency(self): 
        '''getTransparency(self) -> MVectorArray

Return the array of transparency along the curve.'''
        pass

    def getColor(self): 
        '''getColor(self) -> MVectorArray

Return the array of colors along the curve.'''
        pass

    def getParameter(self): 
        '''getParameter(self) -> MDoubleArray

Return the array of parameter along the curve.'''
        pass

    def getWidth(self): 
        '''getWidth(self) -> MDoubleArray

Return the array of tube widths along the curve.'''
        pass

    def getTwist(self): 
        '''getTwist(self) -> MVectorArray

Return the array of twist vectors along the curve.'''
        pass

    def getIncandescence(self): 
        '''getIncandescence(self) -> MVectorArray

Return the array of incandescence along the curve.'''
        pass

    def getFlatness(self): 
        '''getFlatness(self) -> MDoubleArray

Return the array of flatness along the curve.'''
        pass

    def getLine(self): 
        '''getLine(self) -> MVectorArray

Return the array of vertices along the curve.'''
        pass

class MRenderLineArray:
    '''Class for accessing paint effects output curve data.'''
    def __init__(self):
        pass


    def length(self): 
        '''length(self) -> int

Return the number of entries in the array.'''
        pass

    def deleteArray(self): 
        '''deleteArray(self)
Free up the memory held in the render line array. This should be
called once only and only on one copy of the  MRenderLineArray .
(Assignment copies internal pointer data rather than the data its
self)   Reprocessed example '''
        pass

    def renderLine(self, index): 
        '''renderLine(self, index) -> MRenderLine

Arguments:
	[in]	index = int

Return the render line at the defined index.'''
        pass

