
'''
Stub class file for:
OpenMaya

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




class MaterialInputData:
    '''Phong shading parameters for an MPxMaterialInformation instance.'''
    def __init__(self):
        pass


class MAngle:
    '''Manipulate Angular Data.'''
    def __init__(self):
        pass


    def setValue(self, newValue): 
        '''setValue(self, newValue)
Arguments:
	[in]	newValue = double

Set current value.'''
        pass

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

Convert to degrees.'''
        pass

    def uiUnit(self): 
        '''uiUnit(self) -> MAngle.Unit

Working unit.'''
        pass

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

Convert to minutes of arc.'''
        pass

    def asUnits(self, otherUnit): 
        '''asUnits(self, otherUnit) -> double
Returns: Returns:
The current value in the given units

Arguments:
	[in]	otherUnit = MAngle.Unit

Unit conversion.'''
        pass

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

Current value.'''
        pass

    def as_func(self, otherUnit): 
        '''as_func(self, otherUnit) -> double
Returns: Returns:
The current value in the given units

Arguments:
	[in]	otherUnit = MAngle.Unit

Unit conversion.'''
        pass

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

Convert to radians.'''
        pass

    def kInvalid(self):
        '''This is an enum of Unit.
Description: Invalid value.
Value: 0'''
        pass

    def kAngMinutes(self):
        '''This is an enum of Unit.
Description: Minutes of Arc.
Value: 3'''
        pass

    def kLast(self):
        '''This is an enum of Unit.
Description: Last enum value.
Value: 5'''
        pass

    def kDegrees(self):
        '''This is an enum of Unit.
Description: Degrees.
Value: 2'''
        pass

    def kAngSeconds(self):
        '''This is an enum of Unit.
Description: Seconds of Arc.
Value: 4'''
        pass

    def kRadians(self):
        '''This is an enum of Unit.
Description: Radians.
Value: 1'''
        pass

    class Unit:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kAngMinutes
        kLast
        kDegrees
        kAngSeconds
        kRadians
'''
        def __init__(self):
            pass

    def uiToInternal(self, uiValue): 
        '''uiToInternal(self, uiValue) -> double
Returns: Returns:
The value in internal units.

Arguments:
	[in]	uiValue = double

Unit conversion.'''
        pass

    def internalUnit(self): 
        '''internalUnit(self) -> MAngle.Unit

Internal unit.'''
        pass

    def internalToUI(self, internalValue): 
        '''internalToUI(self, internalValue) -> double
Returns: Returns:
The value in UI units

Arguments:
	[in]	internalValue = double

Unit conversion.'''
        pass

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

Convert to seconds of arc.'''
        pass

    def setUnit(self, newUnit): 
        '''setUnit(self, newUnit)
Arguments:
	[in]	newUnit = MAngle.Unit

Set current unit.'''
        pass

    def unit(self): 
        '''unit(self) -> MAngle.Unit

Current unit.'''
        pass

    def setUIUnit(self, newUnit): 
        '''setUIUnit(self, newUnit)
Arguments:
	[in]	newUnit = MAngle.Unit

Set working unit.'''
        pass

class MArgDatabase:
    '''Command argument list parser.Once the syntax for your command has been specified, when the method for the command it called, the providedMArgList instance can be
passed to the MArgDatabase constructor along
with the command's syntax object to parse those arguments. If the
parsing is unsuccessful, then the provided command was
syntactically invalid. If successful, the methods in this class can
be used to extract the values of the arguments to the command.'''
    def __init__(self):
        pass


    def getCommandArgument(self, index, result): 
        '''getCommandArgument(self, index, result)
Arguments:
	[in]	index = int
	[out]	result = MSelectionList

Gets the value of the requested command argument to the command
and appends it to the end of the  MSelectionList  that is passed in.'''
        pass

    def getObjects(self, result): 
        '''getObjects(self, result)
Arguments:
	[out]	result = MStringArray

Gets the list of objects passed to the command as an array of
strings.'''
        pass

    def getFlagArgument(self, flag, index, result): 
        '''getFlagArgument(self, flag, index, result)
Arguments:
	[in]	flag = char
	[in]	index = int
	[out]	result = MSelectionList

Gets the value of the requested flag argument to the given flag
as an  MSelectionList .'''
        pass

class MArgList:
    '''Create and retreive argument lists.'''
    def __init__(self):
        pass


    def asMatrix(self, index): 
        '''asMatrix(self, index) -> MMatrix
Returns: Returns:
The MMatrix
value of the indicated argument.

Arguments:
	[out]	index = int

Get the value of the  MMatrix 
argument at a given position in the arglist.'''
        pass

    def asIntArray(self, index): 
        '''asIntArray(self, index) -> MIntArray
Returns: Returns:
MIntArray

Arguments:
	[out]	index = int

Get the value of the  MIntArray  argument at a
given position in the arglist.'''
        pass

    def asTime(self, index): 
        '''asTime(self, index) -> MTime
Returns: Returns:
The MTime
value of the indicated argument.

Arguments:
	[in]	index = int

Return the value of the argument at a given position in the
arglist as an  MTime .'''
        pass

    def asBool(self, index): 
        '''asBool(self, index) -> bool
Returns: Returns:
The bool value of the indicated argument.

Arguments:
	[in]	index = int

Return the value of the argument at a given position in the
arglist as an bool.'''
        pass

    def asDoubleArray(self, index): 
        '''asDoubleArray(self, index) -> MDoubleArray
Returns: Returns:
MDoubleArray

Arguments:
	[out]	index = int

Get the value of the  MDoubleArray  argument at a given
position in the arglist.'''
        pass

    def asVector(self, numElements, index): 
        '''asVector(self, numElements, index) -> MVector
Returns: Returns:
The MVector value of
the indicated argument.

Arguments:
	[out]	index = int
	[in]	numElements = int

Return the value of the argument at a given position in the
arglist as an  MVector .'''
        pass

    def addArg(self, arg): 
        '''addArg(self, arg)
Arguments:
	[in]	arg = MPoint

Add a new  MPoint  argument to the
arglist.'''
        pass

    def flagIndex(self, shortFlag, longFlag): 
        '''flagIndex(self, shortFlag, longFlag) -> int
Returns: Returns:
The unsigned int index of the indicated argument if it has been
set, kInvalidArgIndex otherwise.

Arguments:
	[in]	shortFlag = char
	[in]	longFlag = char

Return the index entry of the requested flag, if it has been
set.'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of arguments in the arglist.

Returns the number of arguments in the arglist.'''
        pass

    def asDistance(self, index): 
        '''asDistance(self, index) -> MDistance
Returns: Returns:
The MDistance value of the indicated
argument.

Arguments:
	[in]	index = int

Return the value of the argument at a given position in the
arglist as an  MDistance .'''
        pass

    def asStringArray(self, index): 
        '''asStringArray(self, index) -> const MStringArray
Returns: Returns:
MStringArray

Arguments:
	[out]	index = int

Get the value of the  MStringArray  argument at a given
position in the arglist.'''
        pass

    def asPoint(self, numElements, index): 
        '''asPoint(self, numElements, index) -> MPoint
Returns: Returns:
The MPoint value of the indicated
argument.

Arguments:
	[out]	index = int
	[in]	numElements = int

Return the value of the argument at a given position in the
arglist as an  MPoint .'''
        pass

    def asAngle(self, index): 
        '''asAngle(self, index) -> MAngle
Returns: Returns:
The MAngle value of the indicated
argument.

Arguments:
	[in]	index = int

Return the value of the argument at a given position in the
arglist as an  MAngle .'''
        pass

    def asDouble(self, index): 
        '''asDouble(self, index) -> double
Returns: Returns:
The double value of the indicated argument.

Arguments:
	[in]	index = int

Return the value of the argument at a given position in the
arglist as a double.'''
        pass

    def asString(self, index): 
        '''asString(self, index) -> MString
Returns: Returns:
The MString value of the indicated
argument.

Arguments:
	[in]	index = int

Return the value of the argument at a given position in the
arglist as an  MString .'''
        pass

    def asInt(self, index): 
        '''asInt(self, index) -> int
Returns: Returns:
The integer value of the indicated argument.

Arguments:
	[in]	index = int

Return the value of the argument at a given position in the
arglist as an integer.'''
        pass

class MArgParser:
    '''Command argument list parser.Once the syntax for your command has been specified, when the method for the command it called, the providedMArgList instance can be
passed to the MArgParser constructor along
with the command's syntax object to parse those arguments. If the
parsing is unsuccessful, then the provided command was
syntactically invalid. If successful, the methods in this class can
be used to extract the values of the arguments to the command.'''
    def __init__(self):
        pass


    def flagArgumentString(self, flag, index): 
        '''flagArgumentString(self, flag, index) -> MString
Returns: Returns:
The value of the argument as a string

Arguments:
	[in]	flag = char
	[in]	index = int

Gets the value of the requested flag argument to the given flag
as an  MString .'''
        pass

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


true if query flag is set
false if query flag is not set

Determines if the query flag was one of the arguments to the
command. The query flag in its short form is "-q", and in its int
form is "-query".'''
        pass

    def commandArgumentMTime(self, index): 
        '''commandArgumentMTime(self, index) -> MTime
Returns: Returns:
The value of the argument as a MTime

Arguments:
	[in]	index = int

Gets the value of the requested command argument as a  MTime .'''
        pass

    def getFlagArgumentList(self, flag, i, args): 
        '''getFlagArgumentList(self, flag, i, args)
Arguments:
	[in]	flag = char
	[in]	i = int
	[out]	args = MArgList

Returns an  MArgList  containing the
arguments to the i'th usage of the specified flag. This call is
only valid if the flags has been marked as available for
multi-usage with  MSyntax::makeFlagMultiUse'''
        pass

    def commandArgumentMAngle(self, index): 
        '''commandArgumentMAngle(self, index) -> MAngle
Returns: Returns:
The value of the argument as a MAngle

Arguments:
	[in]	index = int

Gets the value of the requested command argument as a  MAngle .'''
        pass

    def flagArgumentDouble(self, flag, index): 
        '''flagArgumentDouble(self, flag, index) -> double
Returns: Returns:
The value of the argument as a double

Arguments:
	[in]	flag = char
	[in]	index = int

Gets the value of the requested flag argument to the given flag
as a double.'''
        pass

    def commandArgumentString(self, index): 
        '''commandArgumentString(self, index) -> MString
Returns: Returns:
The value of the argument as a string

Arguments:
	[in]	index = int

Gets the value of the requested command argument as a
string.'''
        pass

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

Returns the number of flags given on the command line command
line.'''
        pass

    def commandArgumentBool(self, index): 
        '''commandArgumentBool(self, index) -> bool
Returns: Returns:
The value of the argument as a boolean

Arguments:
	[in]	index = int

Gets the value of the requested command argument as a
boolean.'''
        pass

    def commandArgumentDouble(self, index): 
        '''commandArgumentDouble(self, index) -> double
Returns: Returns:
The value of the argument as a double

Arguments:
	[in]	index = int

Gets the value of the requested command argument as a
double.'''
        pass

    def getObjects(self, result): 
        '''getObjects(self, result)
Arguments:
	[out]	result = MStringArray

Gets the list of objects passed to the command as an array of
strings.'''
        pass

    def flagArgumentMAngle(self, flag, index): 
        '''flagArgumentMAngle(self, flag, index) -> MAngle
Returns: Returns:
The value of the argument as an MAngle

Arguments:
	[in]	flag = char
	[in]	index = int

Gets the value of the requested flag argument to the given flag
as an  MAngle .'''
        pass

    def numberOfFlagUses(self, flag): 
        '''numberOfFlagUses(self, flag) -> int
Returns: Returns:
Number of times the given flag was used on the command
line

Arguments:
	[in]	flag = char

Returns the number of times the given flag was used on the
command line.'''
        pass

    def isFlagSet(self, flag): 
        '''isFlagSet(self, flag) -> bool
Returns: Returns:


true if given flag is set
false if given flag is not set

Arguments:
	[in]	flag = char

Queries the arguments to the command to determine if the given
flag is set.'''
        pass

    def getCommandArgument(self, index, result): 
        '''getCommandArgument(self, index, result)
Arguments:
	[in]	index = int
	[out]	result = MTime

Gets the value of the requested command argument to the command
as an  MTime .'''
        pass

    def commandArgumentInt(self, index): 
        '''commandArgumentInt(self, index) -> int
Returns: Returns:
The value of the argument as an int

Arguments:
	[in]	index = int

Gets the value of the requested command argument as an int.'''
        pass

    def commandArgumentMDistance(self, index): 
        '''commandArgumentMDistance(self, index) -> MDistance
Returns: Returns:
The value of the argument as a MDistance

Arguments:
	[in]	index = int

Gets the value of the requested command argument as a  MDistance .'''
        pass

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


true if edit flag is set
false if edit flag is not set

Determines if the edit flag was one of the arguments to the
command. The edit flag in its short form is "-e", and in its int
form is "-edit".'''
        pass

    def getFlagArgument(self, flag, index, result): 
        '''getFlagArgument(self, flag, index, result)
Arguments:
	[in]	flag = char
	[in]	index = int
	[out]	result = MTime

Gets the value of the requested flag argument to the given flag
as an  MTime .'''
        pass

    def getFlagArgumentPosition(self, flag, i, position): 
        '''getFlagArgumentPosition(self, flag, i, position)
Arguments:
	[in]	flag = char
	[in]	i = int
	[out]	position = int

Returns the position in the command line of the i'th usage of a
specified flag. This call is only valid if the flags has been
marked as available for multi-usage with  MSyntax::makeFlagMultiUse'''
        pass

    def flagArgumentMDistance(self, flag, index): 
        '''flagArgumentMDistance(self, flag, index) -> MDistance
Returns: Returns:
The value of the argument as an MDistance

Arguments:
	[in]	flag = char
	[in]	index = int

Gets the value of the requested flag argument to the given flag
as an  MDistance .'''
        pass

    def flagArgumentInt(self, flag, index): 
        '''flagArgumentInt(self, flag, index) -> int
Returns: Returns:
The value of the argument as an int

Arguments:
	[in]	flag = char
	[in]	index = int

Gets the value of the requested flag argument to the given flag
as a int.'''
        pass

    def flagArgumentMTime(self, flag, index): 
        '''flagArgumentMTime(self, flag, index) -> MTime
Returns: Returns:
The value of the argument as an MTime

Arguments:
	[in]	flag = char
	[in]	index = int

Gets the value of the requested flag argument to the given flag
as an  MTime .'''
        pass

    def flagArgumentBool(self, flag, index): 
        '''flagArgumentBool(self, flag, index) -> bool
Returns: Returns:
The value of the argument as a boolean

Arguments:
	[in]	flag = char
	[in]	index = int

Gets the value of the requested flag argument to the given flag
as a boolean.'''
        pass

class MArrayDataBuilder:
    '''Array builder for arrays in data blocks.'''
    def __init__(self):
        pass


    def addElementArray(self, index): 
        '''addElementArray(self, index) -> MArrayDataHandle
Returns: Returns:
The handle for the new array element

Arguments:
	[in]	index = int

Adds a new element to the array at the given index. The added
element is also an array.'''
        pass

    def setGrowSize(self, size): 
        '''setGrowSize(self, size)
Arguments:
	[in]	size = int

Sets the grow size of the array. As elements are added to the
array, the builder will allocate memory in chunks. This method
tells the builder how many elements to allocate each time it grows
the array.'''
        pass

    def addLast(self): 
        '''addLast(self) -> MDataHandle
Returns: Returns:
The handle for the new element

Adds a new element to the end of the array. The index of the
element will be the current highest index + 1.'''
        pass

    def addElement(self, index): 
        '''addElement(self, index) -> MDataHandle
Returns: Returns:
The handle for the new element

Arguments:
	[in]	index = int

Adds a new element to the array at the given index.'''
        pass

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

Returns the number of elements in the array'''
        pass

    def addLastArray(self): 
        '''addLastArray(self) -> MArrayDataHandle
Returns: Returns:
The handle for the new array element

Adds a new element to the end of the array. The added element is
also an array. The index of the element will the current highest
index + 1.'''
        pass

    def growArray(self, amount): 
        '''growArray(self, amount)
Arguments:
	[in]	amount = int

Grows the array storage by the given amount.'''
        pass

    def removeElement(self, index): 
        '''removeElement(self, index)
Arguments:
	[in]	index = int

Removes the specified element from the array'''
        pass

class MArrayDataHandle:
    '''Data block handle for array data.'''
    def __init__(self):
        pass


    def elementIndex(self): 
        '''elementIndex(self) -> int
Returns: Returns:
The current element's logical index

Returns the index that we are currently at in the array. It is
possible for the index to be invalid, in which case the return
status will report an error. These may be sparse arrays so the
element index returned will be a logical index.'''
        pass

    def jumpToElement(self, index): 
        '''jumpToElement(self, index)
Arguments:
	[in]	index = int

Jump to a specific element in the array. The array is sparse, so
the indices may not be consecutive.'''
        pass

    def setAllClean(self): 
        '''setAllClean(self)
Marks every element of the array attribute represented by the
handle as clean. This method should be used if a compute function
is asked to compute a single element of a multi, but instead
calculates all the elements. Calling  setAllClean  in this
situation will prevent further calls to the node's compute method
for the other elements of the multi.'''
        pass

    def outputArrayValue(self): 
        '''outputArrayValue(self) -> MArrayDataHandle
Returns: Returns:
Data handle for the current element's data

Gets a handle into this data block for the current array
element. This method should be used when the array elements are
also arrays. The data is not guaranteed to be valid. Therefore,
this handle should only be used for writing over the data.'''
        pass

    def builder(self): 
        '''builder(self) -> MArrayDataBuilder
Returns: Returns:
The builder object

Returns a builder for this handle's array so that it can be
expanded.'''
        pass

    def next(self): 
        '''next(self)
Advance to the next element in the array. These may be sparse
arrays so the next consecutive element may not necessarily have a
consecutive index.'''
        pass

    def outputValue(self): 
        '''outputValue(self) -> MDataHandle
Returns: Returns:
Data handle for the current element's data

Gets a handle into this data block for the current array
element. The data is not guaranteed to be valid. Therefore, this
handle should only be used for writing over the data.'''
        pass

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

Returns the number of elements in the array.'''
        pass

    def set(self, builder): 
        '''set(self, builder)
Arguments:
	[in]	builder = MArrayDataBuilder

Sets the data for this array from the data in the builder
object'''
        pass

    def inputValue(self): 
        '''inputValue(self) -> MDataHandle
Returns: Returns:
Data handle for the current element's data

Gets a handle into this data block for the current array
element. The data represented by the handle will be valid. If the
data is from an dirty connection, then the connection will be
evaluated.'''
        pass

    def jumpToArrayElement(self, position): 
        '''jumpToArrayElement(self, position)
Arguments:
	[in]	position = int

Jump to a specific array element in the array. This method can
be used to iterate over the entire array.'''
        pass

    def setClean(self): 
        '''setClean(self)
Marks the data that is represented by this handle as being
clean. This should be done after recalculating the data from the
inputs.'''
        pass

    def inputArrayValue(self): 
        '''inputArrayValue(self) -> MArrayDataHandle
Returns: Returns:
Data handle for the current element's data

Gets a handle into this data block for the current array
element. This method should be used when the array elements are
also arrays. The data represented by the handle will be valid. If
the data is from an dirty connection, then the connection will be
evailuated.'''
        pass

class MAttributeIndex:
    '''The index information for an attribute specification.'''
    def __init__(self):
        pass


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

Returns true if this object is bounded.'''
        pass

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

Sets the index value of this object.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:
Boolean indicating whether the objects are same.

Arguments:
	[in]	other = MAttributeIndex

Inequality operator.'''
        pass

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

Return true if a range was specified.'''
        pass

    def getUpper(self, value): 
        '''getUpper(self, value)
Arguments:
	[out]	value = double

Return the upper bound for this object or false if 1) the type
does not match the argument type or 2) there is no upper bound.
(both of which can be tested for using other methods on this
class).'''
        pass

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

Sets the upper bounds of this object.'''
        pass

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

Return true if if there is a lower bound specified.'''
        pass

    def getValue(self, value): 
        '''getValue(self, value)
Arguments:
	[out]	value = double

Return the current value of the index or false if 1) the type
does not match the argument type or 2) the index is a range or 3)
the index is unbounded.'''
        pass

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

Return true if upper value is greater than lower value.'''
        pass

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

Return true if if there is an upper bound specified.'''
        pass

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

Sets the lower bounds of this object.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
Boolean indicating whether the objects are same.

Arguments:
	[in]	other = MAttributeIndex

Equality operator.'''
        pass

    def getLower(self, value): 
        '''getLower(self, value)
Arguments:
	[out]	value = double

Return the lower bound for this object or false if 1) the type
does not match the argument type or 2) there is no lower bound.
(both of which can be tested for using other methods on this
class).'''
        pass

    def type(self): 
        '''type(self) -> MAttributeIndex.MIndexType

Returns the type of attribute index.'''
        pass

    def kInteger(self):
        '''This is an enum of MIndexType.
Description: Integer index (e.g. mesh.cp[5]).
Value: 0'''
        pass

    def kFloat(self):
        '''This is an enum of MIndexType.
Description: Floating-poing index (e.g. curve.u[1.3]).
Value: 1'''
        pass

    class MIndexType:
        '''Non-functional class.  Values for this enum:
        kInteger
        kFloat
'''
        def __init__(self):
            pass

    def setType(self, type): 
        '''setType(self, type)
Arguments:
	[in]	type = MAttributeIndex.MIndexType

Sets the type of attribute index.'''
        pass

class MAttributeSpec:
    '''An attribute specification.'''
    def __init__(self):
        pass


    def setDimensions(self, value): 
        '''setDimensions(self, value)
Arguments:
	[in]	value = int

Set the dimension of the attribute specification. Array
attribute dimensions are > 0.'''
        pass

    def setName(self, name): 
        '''setName(self, name)
Arguments:
	[in]	name = MString

Set the attribute name part of the specification.'''
        pass

    def name(self): 
        '''name(self) -> const MString

Returns the attribute name part of the specification.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MAttributeIndex
Returns: Returns:
The MAttributeIndex
associated with the given index.

Arguments:
	[in]	index = int

Returns an attribute index object for the specified element.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
The boolean indicating whether the object are same or not.

Arguments:
	[in]	other = MAttributeSpec

Comparison operator.'''
        pass

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

Returns the dimension of the attribute specification. For array
attributes the dimension is > 0.'''
        pass

class MAttributeSpecArray:
    '''An attribute specification array.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MAttributeSpec
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MAttributeSpec
	[in]	index = int

Sets the value of the specified element to the given attribute
spec.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MAttributeSpec
Returns: Returns:
A reference to the specified element

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. Valid indices are 0 to  
length() -1.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Removes the element in the array at the given index.'''
        pass

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

Returns the number of elements in the array.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MAttributeSpec

Adds a new element to the end of the array.'''
        pass

class MBoundingBox:
    '''Implementation of a 3D bounding box.'''
    def __init__(self):
        pass


    def intersects(self, box, tol): 
        '''intersects(self, box, tol) -> bool
Returns: Returns:
true if the bounding boxes intersect

Arguments:
	[in]	box = MBoundingBox
	[in]	tol = double

Returns true if the bounding box intersects another given
bounding box'''
        pass

    def center(self): 
        '''center(self) -> MPoint

Returns the center of the bounding box.'''
        pass

    def min(self): 
        '''min(self) -> MPoint

Returns the minimum point for the bounding box. That is the
point whose x, y, and z components represent the bounding box's
minimum value in each dimension.'''
        pass

    def max(self): 
        '''max(self) -> MPoint

Returns the maximum point for the bounding box. That is the
point whose x, y, and z components represent the bounding box's
maximum value in each dimension.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

    def contains(self, point): 
        '''contains(self, point) -> bool
Returns: Returns:
true if the point is contained in this bounding box

Arguments:
	[in]	point = MPoint

Returns true if the bounding box contains the given point.'''
        pass

    def transformUsing(self, matrix): 
        '''transformUsing(self, matrix)
Arguments:
	[in]	matrix = MMatrix

Apply the given transformation to this bounding box.'''
        pass

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

Returns the height of the bounding box.'''
        pass

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

Returns the width of the bounding box.'''
        pass

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

Returns the depth of the bounding box.'''
        pass

    def expand(self, box): 
        '''expand(self, box)
Arguments:
	[in]	box = MBoundingBox

Expand the bounding box to include a second bounding box.'''
        pass

class MCallbackIdArray:
    '''Array of MCallbackId data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MCallbackId
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MCallbackId
	[in]	index = int

Sets the value of the indicated element to the indicated
value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MCallbackId
Returns: Returns:
The value of the indicated element.

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MCallbackIdArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MCallbackId

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MCameraSetMessage:
    '''CameraSet messages.'''
    def __init__(self):
        pass


    def addCameraLayerCallback(self, func, clientData): 
        '''addCameraLayerCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MCameraLayerFunction
	[in]	clientData = void

Registers callbacks for adding and removing camera layeres.'''
        pass

    def addCameraChangedCallback(self, func, clientData): 
        '''addCameraChangedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MCameraLayerCameraFunction
	[in]	clientData = void

Registers callbacks for camera assignment changes to a camera
layer.'''
        pass

class MColor:
    '''A color math class.'''
    def __init__(self):
        pass


    def set(self, colorModel, c1, c2, c3, alpha): 
        '''set(self, colorModel, c1, c2, c3, alpha) -> bool
Returns: Returns:
Always returns bool true.

Arguments:
	[in]	colorModel = MColor.MColorType
	[in]	c1 = float
	[in]	c2 = float
	[in]	c3 = float
	[in]	alpha = float

Color component assigment.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> float
Returns: Returns:
A reference to the appropriate component of the color:

Reference to the red channel when argument is 0.
Reference to the green channel when argument is 1.
Reference to the blue channel when argument is 2.
Reference to the alpha channel otherwise.

Arguments:
	[in]	i = int

Index operator.'''
        pass

    def get(self, colorModel, c1, c2, c3, alpha): 
        '''get(self, colorModel, c1, c2, c3, alpha) -> bool
Returns: Returns:
Always returns bool true.

Arguments:
	[in]	colorModel = MColor.MColorType
	[out]	c1 = float
	[out]	c2 = float
	[out]	c3 = float
	[out]	alpha = float

Color component accessor.'''
        pass

    def kCMY(self):
        '''This is an enum of MColorType.
Description: Cyan, Magenta, Yellow.
Value: 2'''
        pass

    def kHSV(self):
        '''This is an enum of MColorType.
Description: Hue, Saturation, Value.
Value: 1'''
        pass

    def kRGB(self):
        '''This is an enum of MColorType.
Description: Red, Green, Blue.
Value: 0'''
        pass

    def kCMYK(self):
        '''This is an enum of MColorType.
Description: Cyan, Magenta, Yellow, Black.
Value: 3'''
        pass

    class MColorType:
        '''Non-functional class.  Values for this enum:
        kCMY
        kHSV
        kRGB
        kCMYK
'''
        def __init__(self):
            pass

    def __rmult__(self, other): 
        '''__rmult__(self, other) -> MColor
Returns: Returns:
A reference to the color whose value was modified.

Arguments:
	[in]	other = MColor

In place multiply operator.'''
        pass

    def __radd__(self, other): 
        '''__radd__(self, other) -> MColor
Returns: Returns:
A reference to the color whose value was modified.

Arguments:
	[in]	other = MColor

In place add operator.'''
        pass

    def __div__(self, scalar): 
        '''__div__(self, scalar) -> MColor
Returns: Returns:
A new MColor object representing the color
divided by the scalar.

Arguments:
	[in]	scalar = float

Divide operator.'''
        pass

    def __mul__(self, other): 
        '''__mul__(self, other) -> MColor
Returns: Returns:
A new MColor object representing the product of
the two colors.

Arguments:
	[in]	other = MColor

Multiply operator.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MColor
Returns: Returns:
A new MColor object representing the sum of
this color and the specified color.

Arguments:
	[in]	other = MColor

Add operator.'''
        pass

    def __rdiv__(self, scalar): 
        '''__rdiv__(self, scalar) -> MColor
Returns: Returns:
A reference to the color whose value was modified.

Arguments:
	[in]	scalar = float

In place divide operator.'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MColor
Returns: Returns:
A new MColor object representing this color
minus the specified other color.

Arguments:
	[in]	other = MColor

Substraction operator.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
A bool value:

true if the colors are identical
false otherwise

Arguments:
	[in]	other = MColor

Equality operator.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:
A bool value:

false if the colors are identical
true otherwise

Arguments:
	[in]	other = MColor

Inequality operator.'''
        pass

class MColorArray:
    '''Array of MColor data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MColor
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, elements, size): 
        '''set(self, elements, size)
Arguments:
	[in]	elements = double
	[in]	size = int

Resets the values of the color components. The length of the
passed in C++ array should be same as the length of the ColorArray
to which we are setting the values.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MColor
Returns: Returns:
The value of the indicated element.

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float

Copy the elements of the array into the C++ array of float
arrays. No checking is done to ensure that the destination C++
array of float arrays is large enough to hold all the elements of
the instance.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, x, y, z, w): 
        '''append(self, x, y, z, w)
Arguments:
	[in]	x = float
	[in]	y = float
	[in]	z = float
	[in]	w = float

Adds a new element to the end of the array. The appended element
has the indicated values for its x,y,z and w components. The x
component of the element is set to x, the y component to y, the z
component to z, and the w component to w.'''
        pass

class MCommandMessage:
    '''Helper class to handle MEL output.'''
    def __init__(self):
        pass


    def addCommandOutputCallback(self, func, clientData): 
        '''addCommandOutputCallback(self, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	func = MCommandMessage.MMessageFunction
	[in]	clientData = void

This method registers a callback for whenever MEL commands
generate output such as that which is printed into the command
window.'''
        pass

    def addCommandCallback(self, func, clientData): 
        '''addCommandCallback(self, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	func = MMessage.MStringFunction
	[in]	clientData = void

This method registers a callback for command messages that are
issued every time a MEL command is executed. It is only called when
actual commands are executed and not when scripts are executed.'''
        pass

    def addCommandOutputFilterCallback(self, func, clientData): 
        '''addCommandOutputFilterCallback(self, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	func = MCommandMessage.MMessageFilterFunction
	[in]	clientData = void

This method registers a callback for whenever MEL commands
generate output such as that which is printed into the command
window.'''
        pass

    def kStackTrace(self):
        '''This is an enum of MessageType.
Description: Stack trace.
Value: 6'''
        pass

    def kInfo(self):
        '''This is an enum of MessageType.
Description: General information.
Value: 2'''
        pass

    def kHistory(self):
        '''This is an enum of MessageType.
Description: Command history.
Value: 0'''
        pass

    def kDisplay(self):
        '''This is an enum of MessageType.
Description: String to display unmodified.
Value: 1'''
        pass

    def kError(self):
        '''This is an enum of MessageType.
Description: Error message.
Value: 4'''
        pass

    def kResult(self):
        '''This is an enum of MessageType.
Description: Result from a command execution in the command window.
Value: 5'''
        pass

    def kWarning(self):
        '''This is an enum of MessageType.
Description: Warning message.
Value: 3'''
        pass

    class MessageType:
        '''Non-functional class.  Values for this enum:
        kStackTrace
        kInfo
        kHistory
        kDisplay
        kError
        kResult
        kWarning
'''
        def __init__(self):
            pass

class MCommandResult:
    '''Result returned from executing a command.'''
    def __init__(self):
        pass


    def resultType(self): 
        '''resultType(self) -> MCommandResult.Type
Returns: Returns:


MCommandResult::kInt
MCommandResult::kIntArray
MCommandResult::kDouble
MCommandResult::kDoubleArray
MCommandResult::kString
MCommandResult::kStringArray
MCommandResult::kVector
MCommandResult::kVectorArray
MCommandResult::kMatrix
MCommandResult::kInvalid

Returns the type of the result.'''
        pass

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

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

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

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

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

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

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

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

    def kMatrixArray(self):
        '''This is an enum of Type.
Description: 
Value: 10'''
        pass

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

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

    class Type:
        '''Non-functional class.  Values for this enum:
        kDouble
        kIntArray
        kStringArray
        kVectorArray
        kInt
        kString
        kDoubleArray
        kInvalid
        kMatrixArray
        kVector
        kMatrix
'''
        def __init__(self):
            pass

    def stringResult(self): 
        '''stringResult(self) -> MString
Returns: Returns:
The command result

Retrieves the command result which is a string.'''
        pass

    def getResult(self, result, numRows, numColumns): 
        '''getResult(self, result, numRows, numColumns)
Arguments:
	[out]	result = MDoubleArray
	[out]	numRows = int
	[out]	numColumns = int

Retrieves the command result which is a matrix.'''
        pass

class MComputation:
    '''Interupt monitor for long computations.'''
    def __init__(self):
        pass


    def beginComputation(self): 
        '''beginComputation(self)
Mark the beginning of a long computation. The application will
begin looking for user interupts.   Reprocessed example '''
        pass

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

Query whether a user-interrupt has occurred.'''
        pass

    def endComputation(self): 
        '''endComputation(self)
Mark the ending of a long computation. The application will stop
looking for user interupts.   Reprocessed example '''
        pass

class MConditionMessage:
    '''Condition change messages.'''
    def __init__(self):
        pass


    def getConditionNames(self, names): 
        '''getConditionNames(self, names)
Arguments:
	[out]	names = MStringArray

This method returns the list of available condition names.'''
        pass

    def addConditionCallback(self, conditionName, func, clientData): 
        '''addConditionCallback(self, conditionName, func, clientData) -> MCallbackId

Arguments:
	[in]	conditionName = MString
	[in]	func = MMessage.MStateFunction
	[in]	clientData = void

This method registers a callback for condition changed
messages.'''
        pass

    def getConditionState(self, name): 
        '''getConditionState(self, name) -> bool
Returns: Returns:
The current state of the condition.

Arguments:
	[in]	name = MString

This method returns the current state of a condition.'''
        pass

class MContainerMessage:
    '''Container-related messages.'''
    def __init__(self):
        pass


    def addPublishAttrCallback(self, func, clientData): 
        '''addPublishAttrCallback(self, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	func = MMessage.MNodeStringBoolFunction
	[in]	clientData = void

This method registers a callback that is called whenever an
attribute is published or unpublished from a container.'''
        pass

    def addBoundAttrCallback(self, func, clientData): 
        '''addBoundAttrCallback(self, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	func = MMessage.MNodeStringBoolFunction
	[in]	clientData = void

This method registers a callback that is called whenever an
attribute is bound or unbound on a container.'''
        pass

class MDagMessage:
    '''Dependency graph messages.Methods exist to register callbacks for every time any DAG node is
affected as well as methods that work on specific nodes. Each
method returns an id which is used to remove the callback.'''
    def __init__(self):
        pass


    def addInstanceRemovedCallback(self, func, clientData): 
        '''addInstanceRemovedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever an
instance of any DAG node is removed or deleted.'''
        pass

    def addParentRemovedCallback(self, func, clientData): 
        '''addParentRemovedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a
parent is removed in the DAG.'''
        pass

    def addDagCallback(self, node, msgType, func, clientData): 
        '''addDagCallback(self, node, msgType, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	msgType = MDagMessage.DagMessage
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

Obsolete and no script support.'''
        pass

    def addChildRemovedCallback(self, func, clientData): 
        '''addChildRemovedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a child
is removed in the DAG.'''
        pass

    def addParentAddedCallback(self, func, clientData): 
        '''addParentAddedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a
parent is added in the DAG.'''
        pass

    def addDagDagPathCallback(self, node, msgType, func, clientData): 
        '''addDagDagPathCallback(self, node, msgType, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	msgType = MDagMessage.DagMessage
	[in]	func = MDagMessage.MMessageParentChildFunction
	[in]	clientData = void

This method registers a callback that is called for specified a
DAG change is made to the specified DAG path. The callback receives
the DagMessage as well.'''
        pass

    def addChildAddedCallback(self, func, clientData): 
        '''addChildAddedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a child
is added in the DAG.'''
        pass

    def addParentRemovedDagPathCallback(self, node, func, clientData): 
        '''addParentRemovedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a
parent is removed from the specified DAG node.'''
        pass

    def addChildAddedDagPathCallback(self, node, func, clientData): 
        '''addChildAddedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a child
is added to the specified DAG node.'''
        pass

    def addAllDagChangesDagPathCallback(self, node, func, clientData): 
        '''addAllDagChangesDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MDagMessage.MMessageParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a DAG
change is made to the specified DAG path.'''
        pass

    def addInstanceAddedDagPathCallback(self, node, func, clientData): 
        '''addInstanceAddedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever the
specified node is instanced'''
        pass

    def addParentAddedDagPathCallback(self, node, func, clientData): 
        '''addParentAddedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a
parent is added to the specified DAG node..'''
        pass

    def addInstanceAddedCallback(self, func, clientData): 
        '''addInstanceAddedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever any
node in the DAG is instanced'''
        pass

    def kChildReordered(self):
        '''This is an enum of DagMessage.
Description: a child of a DAG node was reordered
Value: 4'''
        pass

    def kInstanceAdded(self):
        '''This is an enum of DagMessage.
Description: a DAG node was instanced
Value: 5'''
        pass

    def kChildRemoved(self):
        '''This is an enum of DagMessage.
Description: a child was removed from a DAG node
Value: 3'''
        pass

    def kParentRemoved(self):
        '''This is an enum of DagMessage.
Description: a parent was removed from a DAG node
Value: 1'''
        pass

    def kInstanceRemoved(self):
        '''This is an enum of DagMessage.
Description: a DAG node instance was removed
Value: 6'''
        pass

    def kLast(self):
        '''This is an enum of DagMessage.
Description: last value of the enum
Value: 7'''
        pass

    def kInvalidMsg(self):
        '''This is an enum of DagMessage.
Description: an invalid message was used.
Value: -1'''
        pass

    def kChildAdded(self):
        '''This is an enum of DagMessage.
Description: a child was added to a DAG node
Value: 2'''
        pass

    def kParentAdded(self):
        '''This is an enum of DagMessage.
Description: a dummy enum used for looping through the message types
Value: 0'''
        pass

    class DagMessage:
        '''Non-functional class.  Values for this enum:
        kChildReordered
        kInstanceAdded
        kChildRemoved
        kParentRemoved
        kInstanceRemoved
        kLast
        kInvalidMsg
        kChildAdded
        kParentAdded
'''
        def __init__(self):
            pass

    def addInstanceRemovedDagPathCallback(self, node, func, clientData): 
        '''addInstanceRemovedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever an
instance of the specified node is removed.'''
        pass

    def addChildRemovedDagPathCallback(self, node, func, clientData): 
        '''addChildRemovedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a child
is removed from the specified DAG node.'''
        pass

    def addAllDagChangesCallback(self, func, clientData): 
        '''addAllDagChangesCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MDagMessage.MMessageParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever any DAG
change is made to any DAG node.'''
        pass

    def addChildReorderedCallback(self, func, clientData): 
        '''addChildReorderedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a child
is reordered in the DAG.'''
        pass

    def addChildReorderedDagPathCallback(self, node, func, clientData): 
        '''addChildReorderedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void

This method registers a callback that is called whenever a child
of the specified DAG node is reordered.'''
        pass

class MDagModifier:
    '''Dependency graph modifier.'''
    def __init__(self):
        pass


    def createNode(self, type, parent): 
        '''createNode(self, type, parent) -> MObject
Returns: Returns:
A handle for the new node, or the transform above if one is
created as a parent.

Arguments:
	[in]	type = MString
	[in]	parent = MObject

This method adds an operation to this DAG modifier that will add
a new node of the given type to the DAG. This method may not be
used to construct new dependency graph nodes that are not in the
DAG. Use  MDGModifier  for that purpose.'''
        pass

    def reparentNode(self, node, newParent): 
        '''reparentNode(self, node, newParent)
Arguments:
	[in]	node = MObject
	[out]	newParent = MObject

This method adds an operation to this DAG modifier that will
reparent a node in the DAG. If the parent passed in is NULL, then
the node will be reparented under the world.'''
        pass

class MDagPath:
    '''DAG Path.'''
    def __init__(self):
        pass


    def set(self, src): 
        '''set(self, src)
Arguments:
	[in]	src = MDagPath

Sets this DAG Path equal to the specified DAG Path.'''
        pass

    def fullPathName(self): 
        '''fullPathName(self) -> MString
Returns: Returns:
The full path name

Return a string representing the full path from the root of the
dag to this object.'''
        pass

    def pop(self, num): 
        '''pop(self, num)
Arguments:
	[in]	num = int

Pop the given number of objects off of the end of the path.'''
        pass

    def getAPathTo(self, node, path): 
        '''getAPathTo(self, node, path)
Arguments:
	[in]	node = MObject
	[out]	path = MDagPath

Determines the Path to the specified DAG Node. The Path returned
is rooted at the World. If the object is instanced and has multiple
paths, then the first one that is found is returned.'''
        pass

    def hasFn(self, type): 
        '''hasFn(self, type) -> bool
Returns: Returns:
Boolean value indicating whether the function set is
supported

Arguments:
	[in]	type = MFn.Type

Returns true if the object at the end of this DAG path supports
the given function set.'''
        pass

    def partialPathName(self): 
        '''partialPathName(self) -> MString
Returns: Returns:
The partial path name

Return a string representing the partial path from the root of
the dag to this object.'''
        pass

    def transform(self): 
        '''transform(self) -> MObject
Returns: Returns:
Lowest Transform for this DAG Path

Retrieves the lowest Transform in the DAG Path.'''
        pass

    def getPath(self, i, path): 
        '''getPath(self, i, path)
Arguments:
	[out]	path = MDagPath
	[in]	i = int

Return the i'th path. The zero'th path is the top-most path and
must be rooted by the world. Additional paths are paths in the
underworld of the object at the end of the previous path (path
i-1).'''
        pass

    def numberOfShapesDirectlyBelow(self, num): 
        '''numberOfShapesDirectlyBelow(self, num)
Arguments:
	[out]	num = int

If the object at the end of this path is a transform, this
method will return the number of shapes directly below the
transform.'''
        pass

    def childCount(self): 
        '''childCount(self) -> int
Returns: Returns:
The number of children

Return the number of children that the object at the end of the
path has.'''
        pass

    def node(self): 
        '''node(self) -> MObject
Returns: Returns:
DAG Node for this DAG Path

Retrieves the DAG Node for this DAG Path.'''
        pass

    def inclusiveMatrix(self): 
        '''inclusiveMatrix(self) -> MMatrix
Returns: Returns:
The matrix for all Transforms in the Path including the the end
Node in the Path if it is a Transform

Determines the inclusive matrix of the Path.'''
        pass

    def getAllPathsTo(self, node, pathArray): 
        '''getAllPathsTo(self, node, pathArray)
Arguments:
	[in]	node = MObject
	[out]	pathArray = MDagPathArray

Determines all Paths to the specified DAG Node.'''
        pass

    def extendToShapeDirectlyBelow(self, index): 
        '''extendToShapeDirectlyBelow(self, index)
Arguments:
	[in]	index = int

This method is used if the end of the path is a transform and
there are shapes directly below the transform. The shape to extend
to is set by passing in an appropriate index parameter.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool
Returns: Returns:
True if valid

Determines if Path is valid.'''
        pass

    def apiType(self): 
        '''apiType(self) -> MFn.Type
Returns: Returns:
Type of the object

Returns the type of the object at the end of the path.'''
        pass

    def pathCount(self): 
        '''pathCount(self) -> int
Returns: Returns:
The path count

Return the number of paths which make up this path.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject
Returns: Returns:
A handle to the child

Arguments:
	[in]	index = int

Return the child object at the given index, where the parent is
the object at the end of the path.'''
        pass

    def __eq__(self, src): 
        '''__eq__(self, src) -> bool
Returns: Returns:
True is the objects are equal

Arguments:
	[in]	src = MDagPath

Determines if the DAG Path on the LHS of the operator is equal
to the DAG Path on the RHS.'''
        pass

    def inclusiveMatrixInverse(self): 
        '''inclusiveMatrixInverse(self) -> MMatrix
Returns: Returns:
The inverse of the matrix for all Transforms in the Path
including the end Node in the Path if it is a Transform

Determines the inverse inclusive matrix of the Path.'''
        pass

    def extendToShape(self): 
        '''extendToShape(self)
If the object at the end of this path is a transform and there
is a shape node directly beneath it in the hierarchy, then the path
is extended to that geometry node.'''
        pass

    def exclusiveMatrixInverse(self): 
        '''exclusiveMatrixInverse(self) -> MMatrix
Returns: Returns:
The inverse of the matrix for all transforms in the Path
excluding the end Node in the Path if it is Transform

Determines the inverse exclusive matrix of the Path.'''
        pass

    def instanceNumber(self): 
        '''instanceNumber(self) -> int
Returns: Returns:
The instance number represented by this path

For an instanced object, this returns the instance number that
this path represents in the DAG. The instance number can be used to
determine which element of the world space array attributes of a
DAG node to connect to get information regarding this instance.'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
Number of DAG Nodes not including the root

Determines the number of DAG Nodes in the Path not including the
root.'''
        pass

    def exclusiveMatrix(self): 
        '''exclusiveMatrix(self) -> MMatrix
Returns: Returns:
The matrix for all transforms in the Path excluding the end
Node in the Path if it is Transform

Determines the exclusive matrix of the Path.'''
        pass

    def push(self, child): 
        '''push(self, child)
Arguments:
	[in]	child = MObject

Push an object onto the end of the path. The object must be a
child of the object that is currently at the end of the path.'''
        pass

    def isInstanced(self): 
        '''isInstanced(self) -> bool
Returns: Returns:
True if the DAG node at the end of the path is instanced

Returns true if the object at the end of the DAG path is
instanced. It is instanced if there is more than one path to the
node from the top of the DAG. Each instance of the node will be
drawn separately in the view, but the geometry will be shared.'''
        pass

class MDagPathArray:
    '''Indexable Array of DAG Paths.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MDagPath
	[in]	index = int

Inserts the given DAG Path at the specified index in the
array.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MDagPath
Returns: Returns:
DAG Path at the specified index

Arguments:
	[in]	index = int

Retrieves the DAG Path which is at the specified index in the
array.'''
        pass

    def clear(self): 
        '''clear(self)
Clears this array. Length of the array becomes zero.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Removes the DAG Path which is at the specified index in the
array.'''
        pass

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

Determines the number of elements in the array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MDagPath

Appends the given DAG Path to the end of the array.'''
        pass

class MDataBlock:
    '''Dependency node data block.'''
    def __init__(self):
        pass


    def setContext(self, ctx): 
        '''setContext(self, ctx)
Arguments:
	[in]	ctx = MDGContext

Set the dependency graph context for this data block. The
context is used to specify how a dependency node is going to be
evaluated, thus replacing the context for the given datablock. This
does not modify the dirty state of the datablock so that they apply
to the new context.'''
        pass

    def outputArrayValue(self, attribute): 
        '''outputArrayValue(self, attribute) -> MArrayDataHandle
Returns: Returns:
Array data handle for the given attribute's data

Arguments:
	[in]	attribute = MObject

Gets a handle to this data block for the given attributes's
data. The data is not guaranteed to be valid. No dependency graph
evaluations will be done. Therefore, this handle should be used
only for writing.'''
        pass

    def isClean(self, attribute): 
        '''isClean(self, attribute) -> bool
Returns: Returns:
true if the attribute is clean, false
otherwise.

Arguments:
	[in]	attribute = MObject

Queries the dependency graph to see whether the given attribute
is clean.'''
        pass

    def outputValue(self, attribute): 
        '''outputValue(self, attribute) -> MDataHandle
Returns: Returns:
Data handle for the given attribute's data

Arguments:
	[in]	attribute = MObject

Gets a handle to this data block for the given attributes's
data. The data is not guaranteed to be valid. No dependency graph
evaluations will be done. Therefore, this handle should be used
only for writing.'''
        pass

    def inputValue(self, attribute): 
        '''inputValue(self, attribute) -> MDataHandle
Returns: Returns:
Data handle for the given attributes's data

Arguments:
	[in]	attribute = MObject

Gets a handle to this data block for the given plug's data. The
data represented by the handle is guaranteed to be valid for
reading. If the data is from a dirty connection, then the
connection will be evaluated. If no connection is present, then the
value that the plug has been set to will be returned. If the plug
has not been set to a particular value, then the default value will
be returned.'''
        pass

    def context(self): 
        '''context(self) -> MDGContext
Returns: Returns:
The dependency graph context

Returns a copy of the dependecy graph context for which this
data block was created. The context is used to specify how a
dependency node is going to be evaluated.'''
        pass

    def setClean(self, attribute): 
        '''setClean(self, attribute)
Arguments:
	[in]	attribute = MObject

Tells the dependency graph that the given attribute has been
updated and is now clean. This should be called after the data in
the plug has been recalculated from the inputs of the node.'''
        pass

    def inputArrayValue(self, attribute): 
        '''inputArrayValue(self, attribute) -> MArrayDataHandle
Returns: Returns:
Array data handle for the given attributes's data

Arguments:
	[in]	attribute = MObject

Gets an array handle to this data block for the given plug's
data. This is only valid if the given plug has array data. The data
represented by the handle will be valid. If the data is from a
dirty connection, then the connection will be evaluated. If no
connection is present, then the value that the plug has been set to
will be returned. If the plug has not been set to a particular
value, then the default value will be returned.'''
        pass

class MDataHandle:
    '''Data handle for information contained in a data block.'''
    def __init__(self):
        pass


    def asFloat2(self): 
        '''asFloat2(self) -> float2&

Returns the data represented by this handle in the data
block.'''
        pass

    def typeId(self): 
        '''typeId(self) -> MTypeId

Returns the type of data represented by this handle as a type
id. A type id is a four character code that is used to identify the
data type. If no data exists for this handle, the type id will be
0x0.'''
        pass

    def set3Short(self, val1, val2, val3): 
        '''set3Short(self, val1, val2, val3)
Arguments:
	[in]	val1 = short
	[in]	val2 = short
	[in]	val3 = short

Set the data that this handle represents in the data block.'''
        pass

    def set(self, data): 
        '''set(self, data)
Arguments:
	[in]	data = MPxData

No script support.'''
        pass

    def asInt3(self): 
        '''asInt3(self) -> int3&

Returns the data represented by this handle in the data
block.'''
        pass

    def asInt2(self): 
        '''asInt2(self) -> int2&

Returns the data represented by this handle in the data
block.'''
        pass

    def asDouble2(self): 
        '''asDouble2(self) -> double2&

Returns the data represented by this handle in the data
block.'''
        pass

    def asFloat3(self): 
        '''asFloat3(self) -> float3&

Returns the data represented by this handle in the data
block.'''
        pass

    def numericType(self): 
        '''numericType(self) -> MFnNumericData.Type

Returns the type of data represented by this handle. This method
is only valid for data handles of simple numeric types.'''
        pass

    def child(self, attribute): 
        '''child(self, attribute) -> MDataHandle
Returns: Returns:
The data handle for the child

Arguments:
	[in]	attribute = MObject

Get a handle to a child of this handle. This is used if you have
a handle to a compound attribute.'''
        pass

    def set3Float(self, val1, val2, val3): 
        '''set3Float(self, val1, val2, val3)
Arguments:
	[in]	val1 = float
	[in]	val2 = float
	[in]	val3 = float

Set the data that this handle represents in the data block.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the mesh
function set ( MFnMesh ) or any of the mesh
iterators.'''
        pass

    def asShort(self): 
        '''asShort(self) -> short&

Returns the data represented by this handle in the data
block.'''
        pass

    def set2Double(self, val1, val2): 
        '''set2Double(self, val1, val2)
Arguments:
	[in]	val1 = double
	[in]	val2 = double

Set the data that this handle represents in the data block.'''
        pass

    def setMObject(self, data): 
        '''setMObject(self, data)
Arguments:
	[in]	data = MObject

Set the data that this handle represents in the data block. This
method assumes that the  MObject  is a dependency graph data
object. These objects can be created using the appropriate
 MFn ..Data function set. Note
that this method cannot be used to copy compound or multi
attributes from one handle to another via the construct
outputHandle.set (inputHandle.data()). To copy these user defined
attributes, the method  MDataHandle::copy 
must be used.'''
        pass

    def setBool(self, val): 
        '''setBool(self, val)
Arguments:
	[in]	val = bool

Set the data that this handle represents in the data block.'''
        pass

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

Returns true if this handle is for simple numeric data. That
means that the numeric data is directly accessible through the
non-generic as*() and set*() methods of this handle. For example,
depending on handle initialization, the  asBool() 
may be called but the  asGenericBool() 
should not be called.'''
        pass

    def setMTime(self, val): 
        '''setMTime(self, val)
Arguments:
	[in]	val = MTime

Set the data that this handle represents in the data block.'''
        pass

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

Returns the data represented by this handle in the data
block.'''
        pass

    def setMFloatMatrix(self, val): 
        '''setMFloatMatrix(self, val)
Arguments:
	[in]	val = MFloatMatrix

Set the data that this handle represents in the data block.'''
        pass

    def asPluginData(self): 
        '''asPluginData(self) -> MPxData

Returns the data represented by this handle in the data block.
The object is returned as plugin data. This should be used to
access data types defined by plugins.'''
        pass

    def setGenericDouble(self, value, force): 
        '''setGenericDouble(self, value, force)
Arguments:
	[in]	value = double
	[in]	force = bool

Set the data that this handle represents in the data block.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the mesh
function set and iterators. Even though this method does not return
a reference to an  MObject , modifications to the  MObject  instance will update
the contents of the handle in the data block. The method  MDataHandle::setClean 
should be called after the data block has been modified.'''
        pass

    def asChar(self): 
        '''asChar(self) -> char&

Returns the data represented by this handle in the data
block.'''
        pass

    def copy(self, src): 
        '''copy(self, src)
Arguments:
	[in]	src = MDataHandle

Copies the attribute from the  src  attribute to the
attribute referenced by this handle. This is the only method which
can completely copy a compound attribute from one handle to
another. The construct outputHandle.set (inputHandle.data()) will
not work for compound or multi attributes.'''
        pass

    def setMMatrix(self, val): 
        '''setMMatrix(self, val)
Arguments:
	[in]	val = MMatrix

Set the data that this handle represents in the data block. This
method is only valid for attributes created using the  MFnMatrixAttribute  function
set.'''
        pass

    def set2Int(self, val1, val2): 
        '''set2Int(self, val1, val2)
Arguments:
	[in]	val1 = int
	[in]	val2 = int

Set the data that this handle represents in the data block.'''
        pass

    def asDouble3(self): 
        '''asDouble3(self) -> double3&

Returns the data represented by this handle in the data
block.'''
        pass

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

Returns the generic data represented by this handle in the data
block.'''
        pass

    def isGeneric(self, isNumeric, isNull): 
        '''isGeneric(self, isNumeric, isNull) -> bool
Returns: Returns:
True will be returned if this handle points to a generic
attribute

Arguments:
	[out]	isNumeric = bool
	[out]	isNull = bool

Returns true if this handle is for generic data. There are 2
forms of generic data. The first is for simple data and is used if
the isNumeric parameter returns true. In this case, the
asGeneric*() and setGeneric*() methods of this class are used to
query and set values. The second form of generic data is for more
complex attribute types. As a result the type of the object must be
checked and an appropriate attribute function set initialized with
the object.'''
        pass

    def setChar(self, val): 
        '''setChar(self, val)
Arguments:
	[in]	val = char

Set the data that this handle represents in the data block.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the
subdivision surface function set and iterator. Even though this
method does not return a reference to an  MObject , modifications to the  MObject  instance will update
the contents of the handle in the data block. The method  MDataHandle::setClean 
should be called after the data block has been modified.'''
        pass

    def setMAngle(self, val): 
        '''setMAngle(self, val)
Arguments:
	[in]	val = MAngle

Set the data that this handle represents in the data block.'''
        pass

    def setGenericChar(self, value, force): 
        '''setGenericChar(self, value, force)
Arguments:
	[in]	value = char
	[in]	force = bool

Set the data that this handle represents in the data block.'''
        pass

    def asAngle(self): 
        '''asAngle(self) -> MAngle

Returns the data represented by this handle in the data
block.'''
        pass

    def asGenericFloat(self): 
        '''asGenericFloat(self) -> float

Returns the generic data represented by this handle in the data
block.'''
        pass

    def asFloat(self): 
        '''asFloat(self) -> float&

Returns the data represented by this handle in the data
block.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the
subdivision surface function set (MFnSubdSurface) or the
subdivision surface iterators ( MItSubdVertex ,  MItSubdFace ,  MItSubdEdge ).'''
        pass

    def asMatrix(self): 
        '''asMatrix(self) -> MMatrix

Returns the data represented by this handle in the data block.
This method is only valid for attributes created using the
 MFnMatrixAttribute  function
set.'''
        pass

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

Returns the type of data represented by this handle.'''
        pass

    def setString(self, val): 
        '''setString(self, val)
Arguments:
	[in]	val = MString

Set the data that this handle represents in the data block.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the
nurbs curve function set ( MFnNurbsCurve ) or the nurbs curve
CV iterator ( MItCurveCV ).'''
        pass

    def asTime(self): 
        '''asTime(self) -> MTime

Returns the data represented by this handle in the data block.
Even though this method does not return a reference to an  MTime ,
modifications to the  MTime 
instance will update the contents of the handle in the data block.
The method  MDataHandle::setClean 
should be called after the data block has been modified.'''
        pass

    def setDouble(self, val): 
        '''setDouble(self, val)
Arguments:
	[in]	val = double

Set the data that this handle represents in the data block.'''
        pass

    def asGenericShort(self): 
        '''asGenericShort(self) -> short

Returns the generic data represented by this handle in the data
block.'''
        pass

    def set2Short(self, val1, val2): 
        '''set2Short(self, val1, val2)
Arguments:
	[in]	val1 = short
	[in]	val2 = short

Set the data that this handle represents in the data block.'''
        pass

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

Returns the generic data represented by this handle in the data
block.'''
        pass

    def asAddr(self): 
        '''asAddr(self) -> void*&

Returns the data represented by this handle in the data
block.'''
        pass

    def setMDistance(self, val): 
        '''setMDistance(self, val)
Arguments:
	[in]	val = MDistance

Set the data that this handle represents in the data block.'''
        pass

    def asVector(self): 
        '''asVector(self) -> MVector

Returns the data represented by this handle in the data
block.'''
        pass

    def setShort(self, val): 
        '''setShort(self, val)
Arguments:
	[in]	val = short

Set the data that this handle represents in the data block.'''
        pass

    def set2Float(self, val1, val2): 
        '''set2Float(self, val1, val2)
Arguments:
	[in]	val1 = float
	[in]	val2 = float

Set the data that this handle represents in the data block.'''
        pass

    def setGenericShort(self, value, force): 
        '''setGenericShort(self, value, force)
Arguments:
	[in]	value = short
	[in]	force = bool

Set the data that this handle represents in the data block.'''
        pass

    def asDistance(self): 
        '''asDistance(self) -> MDistance

Returns the data represented by this handle in the data
block.'''
        pass

    def asGenericChar(self): 
        '''asGenericChar(self) -> char

Returns the generic data represented by this handle in the data
block.'''
        pass

    def setMVector(self, val): 
        '''setMVector(self, val)
Arguments:
	[in]	val = MVector

Set the data that this handle represents in the data block.'''
        pass

    def setGenericBool(self, value, force): 
        '''setGenericBool(self, value, force)
Arguments:
	[in]	value = bool
	[in]	force = bool

Set the data that this handle represents in the data block.'''
        pass

    def acceptedTypeIds(self, typids): 
        '''acceptedTypeIds(self, typids)
Arguments:
	[out]	typids = MUintArray

This method returns an array of  MTypeId  ids that the
data handle can accept. The  MTypeId  can be
reconstructed using the unsigned int in id.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the
nurbs surface function set ( MFnNurbsSurface ) or the nurbs
surface CV iterator ( MItSurfaceCV ).'''
        pass

    def asUChar(self): 
        '''asUChar(self) -> char&

Returns the data represented by this handle in the data
block.'''
        pass

    def setClean(self): 
        '''setClean(self)
Marks the data that is represented by this handle as being
clean. This should be done after recalculating the data from the
inputs.   Reprocessed example '''
        pass

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

Returns the data object from this handle. The object returned
should be used with the appropriate data function set. This method
is not valid for simple numeric types.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the
nurbs surface function set and iterator. Even though this method
does not return a reference to an  MObject , modifications to the  MObject  instance will update
the contents of the handle in the data block. The method  MDataHandle::setClean 
should be called after the data block has been modified.'''
        pass

    def setMPxData(self, data): 
        '''setMPxData(self, data)
Arguments:
	[in]	data = MPxData

Set the data that this handle represents in the data block. This
method takes a pointer to a user defined data object. The data
block will become the new owner of the data object that you pass
in. Do not delete it.'''
        pass

    def setMFloatVector(self, val): 
        '''setMFloatVector(self, val)
Arguments:
	[in]	val = MFloatVector

Set the data that this handle represents in the data block.'''
        pass

    def geometryTransformMatrix(self): 
        '''geometryTransformMatrix(self) -> const MMatrix

This method returns a reference to the local-to-world
transformation matrix that can accompany a geometry data object.
Only use this method on handles to geometry data (curves, surfaces,
and meshes).'''
        pass

    def asFloatVector(self): 
        '''asFloatVector(self) -> MFloatVector

Returns the data represented by this handle in the data
block.'''
        pass

    def asBool(self): 
        '''asBool(self) -> bool&

Returns the data represented by this handle in the data
block.'''
        pass

    def set3Int(self, val1, val2, val3): 
        '''set3Int(self, val1, val2, val3)
Arguments:
	[in]	val1 = int
	[in]	val2 = int
	[in]	val3 = int

Set the data that this handle represents in the data block.'''
        pass

    def setInt(self, val): 
        '''setInt(self, val)
Arguments:
	[in]	val = int

Set the data that this handle represents in the data block.'''
        pass

    def asFloatMatrix(self): 
        '''asFloatMatrix(self) -> MFloatMatrix

Returns the data represented by this handle in the data block.
This method is only valid for attributes created using the
 MFnMatrixAttribute  function
set.'''
        pass

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

Returns the generic data represented by this handle in the data
block.'''
        pass

    def setGenericFloat(self, value, force): 
        '''setGenericFloat(self, value, force)
Arguments:
	[in]	value = float
	[in]	force = bool

Set the data that this handle represents in the data block.'''
        pass

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

Returns the data represented by this handle in the data block.
The object returned by this call may be used directly with the
nurbs curve function set and iterator. Even though this method does
not return a reference to an  MObject , modifications to the  MObject  instance will update
the contents of the handle in the data block. The method  MDataHandle::setClean 
should be called after the data block has been modified.'''
        pass

    def set3Double(self, val1, val2, val3): 
        '''set3Double(self, val1, val2, val3)
Arguments:
	[in]	val1 = double
	[in]	val2 = double
	[in]	val3 = double

Set the data that this handle represents in the data block.'''
        pass

    def asDouble(self): 
        '''asDouble(self) -> double&

Returns the data represented by this handle in the data
block.'''
        pass

    def asShort2(self): 
        '''asShort2(self) -> short2&

Returns the data represented by this handle in the data
block.'''
        pass

    def asShort3(self): 
        '''asShort3(self) -> short3&

Returns the data represented by this handle in the data
block.'''
        pass

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

Set the data that this handle represents in the data block.'''
        pass

    def asInt(self): 
        '''asInt(self) -> int&

Returns the data represented by this handle in the data
block.'''
        pass

    def setGenericInt(self, value, force): 
        '''setGenericInt(self, value, force)
Arguments:
	[in]	value = int
	[in]	force = bool

Set the data that this handle represents in the data block.'''
        pass

class MDistance:
    '''Manipulate Linear Data.'''
    def __init__(self):
        pass


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

Return the current value of this instance in millimeters.'''
        pass

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

Return the current value of this instance in miles.'''
        pass

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

Return the current value of this instance in feet.'''
        pass

    def setValue(self, newValue): 
        '''setValue(self, newValue)
Arguments:
	[in]	newValue = double

Set the value of this instance'''
        pass

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

Return the current value of this instance in yards.'''
        pass

    def uiUnit(self): 
        '''uiUnit(self) -> MDistance.Unit

Returns the Working Units (or UI units) chosen in the settings
of the prefs window.'''
        pass

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

Return the current value of this instance in meters.'''
        pass

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

Return the current value of this instance in kilometers.'''
        pass

    def asUnits(self, otherUnit): 
        '''asUnits(self, otherUnit) -> double
Returns: Returns:
The current value in the given units

Arguments:
	[in]	otherUnit = MDistance.Unit

Return the current value of this instance in the provided
units.'''
        pass

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

Return the current value of this instance in centimeters.'''
        pass

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

Return the value of the current instance in the currently set
units.'''
        pass

    def as_func(self, otherUnit): 
        '''as_func(self, otherUnit) -> double
Returns: Returns:
The current value in the given units

Arguments:
	[in]	otherUnit = MDistance.Unit

Return the current value of this instance in the provided
units.'''
        pass

    def kMeters(self):
        '''This is an enum of Unit.
Description: Meters.
Value: 8'''
        pass

    def kMillimeters(self):
        '''This is an enum of Unit.
Description: Millimeters.
Value: 5'''
        pass

    def kYards(self):
        '''This is an enum of Unit.
Description: Yards.
Value: 3'''
        pass

    def kKilometers(self):
        '''This is an enum of Unit.
Description: Kilometers.
Value: 7'''
        pass

    def kFeet(self):
        '''This is an enum of Unit.
Description: Feet.
Value: 2'''
        pass

    def kCentimeters(self):
        '''This is an enum of Unit.
Description: Centimeters.
Value: 6'''
        pass

    def kInches(self):
        '''This is an enum of Unit.
Description: Inches.
Value: 1'''
        pass

    def kMiles(self):
        '''This is an enum of Unit.
Description: Miles.
Value: 4'''
        pass

    class Unit:
        '''Non-functional class.  Values for this enum:
        kMeters
        kMillimeters
        kYards
        kKilometers
        kFeet
        kCentimeters
        kInches
        kMiles
'''
        def __init__(self):
            pass

    def uiToInternal(self, uiValue): 
        '''uiToInternal(self, uiValue) -> double
Returns: Returns:
The value in internal units.

Arguments:
	[in]	uiValue = double

Converts a value from UI units to internal units.'''
        pass

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

Return the current value of this instance in inches.'''
        pass

    def internalUnit(self): 
        '''internalUnit(self) -> MDistance.Unit

Returns the internal unit system.'''
        pass

    def internalToUI(self, internalValue): 
        '''internalToUI(self, internalValue) -> double
Returns: Returns:
The value in UI units

Arguments:
	[in]	internalValue = double

Converts a value from internal units to UI units.'''
        pass

    def setUnit(self, newUnit): 
        '''setUnit(self, newUnit)
Arguments:
	[in]	newUnit = MDistance.Unit

Set the units used by this instance.'''
        pass

    def unit(self): 
        '''unit(self) -> MDistance.Unit

Return the units currently in effect for this instance.'''
        pass

    def setUIUnit(self, newUnit): 
        '''setUIUnit(self, newUnit)
Arguments:
	[in]	newUnit = MDistance.Unit

Set the unit system to be used by the user in the UI.'''
        pass

class MDoubleArray:
    '''Array of doubles data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = double
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = float
	[in]	index = int

Sets the value of the indicated element to the indicated float
value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = float

Copy the elements of the array into the given C++ array of
floats. No checking is done to ensure that the destination C++
array of floats is large enough to hold all the elements of the
instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MDoubleArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = double

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MDGContext:
    '''Dependency graph (DG) context class.'''
    def __init__(self):
        pass


    def getTime(self, timeVal): 
        '''getTime(self, timeVal)
Arguments:
	[out]	timeVal = MTime

Return the single time for which this context is valid. The
context must be a timed context, i.e. not a normal one.'''
        pass

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


true this context is normal
false this context is not normal

Determines if this context is that of "normal" evaluation.'''
        pass

class MDGMessage:
    '''Dependency graph messages.A filter can be specified for node added/removed messages. The
default node type is "dependNode" which matches all nodes. Each
method returns an id which is used to remove the callback.'''
    def __init__(self):
        pass


    def addNodeRemovedCallback(self, func, nodeType, clientData): 
        '''addNodeRemovedCallback(self, func, nodeType, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MNodeFunction
	[in]	nodeType = MString
	[in]	clientData = void

This method registers a callback that is called whenever a new
node is removed from the dependency graph. The nodeType argument
allows you to specify the type of nodes that will trigger the
callback. The default node type is "dependNode" which matches all
nodes.'''
        pass

    def addConnectionCallback(self, func, clientData): 
        '''addConnectionCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MPlugFunction
	[in]	clientData = void

This method registers a callback that is called whenever a
connection is made or broken in the dependency graph. This callback
is triggered after the given connection has been made or broken,
unlike the addPreConnectionCallback which is triggered before the
operation.'''
        pass

    def addNodeAddedCallback(self, func, nodeType, clientData): 
        '''addNodeAddedCallback(self, func, nodeType, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MNodeFunction
	[in]	nodeType = MString
	[in]	clientData = void

This method registers a callback that is called whenever a new
node is added to the dependency graph. The nodeType argument allows
you to specify the type of nodes that will trigger the callback.
The default node type is "dependNode" which matches all nodes.'''
        pass

    def addForceUpdateCallback(self, func, clientData): 
        '''addForceUpdateCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MTimeFunction
	[in]	clientData = void

This method registers a callback that is called after the time
changes and after all nodes have been evaluated in the dependency
graph.'''
        pass

    def addPreConnectionCallback(self, func, clientData): 
        '''addPreConnectionCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MPlugFunction
	[in]	clientData = void

This method registers a callback that is called whenever any
connection is made or broken in the dependency graph. This callback
is triggered before the given connection has been made or broken,
unlike the addConnectionCallback which is triggered after the
operation.'''
        pass

    def addTimeChangeCallback(self, func, clientData): 
        '''addTimeChangeCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MTimeFunction
	[in]	clientData = void

This method registers a callback that is called whenever the
time changes in the dependency graph.'''
        pass

class MDGModifier:
    '''Dependency graph modifier.'''
    def __init__(self):
        pass


    def doIt(self): 
        '''doIt(self)
Executes all of the operations that have been given to this
modifier. It is only valid to call this method after all of the
operations have been specified. This method may also be called
after undoIt to redo the operations.'''
        pass

    def deleteNode(self, node): 
        '''deleteNode(self, node)
Arguments:
	[in]	node = MObject

This method adds an operation to this dependency graph modifier
that will delete a dependency graph node from the dependency
graph.'''
        pass

    def disconnect(self, source, dest): 
        '''disconnect(self, source, dest)
Arguments:
	[in]	source = MPlug
	[in]	dest = MPlug

Adds an operation to this dependency graph modifier that
disconnects two plugs in the dependency graph.'''
        pass

    def removeAttribute(self, node, attribute, type): 
        '''removeAttribute(self, node, attribute, type)
Arguments:
	[in]	node = MObject
	[in]	attribute = MObject
	[in]	type = MFnDependencyNode.MAttrClass

Removes a dynamic attribute from the given dependency node.'''
        pass

    def createNode(self, type): 
        '''createNode(self, type) -> MObject
Returns: Returns:
A handle for the new node

Arguments:
	[in]	type = MString

This method adds an operation to this dependency graph modifier
that will add a new dependency graph node of the given type to the
dependency graph. This method may not be used to construct new DAG
nodes. Use  MDagModifier  for that purpose.'''
        pass

    def setNodeLockState(self, node, newState): 
        '''setNodeLockState(self, node, newState)
Arguments:
	[in]	node = MObject
	[in]	newState = bool

This method adds an operation to this dependency graph modifier
that will set the lock state of the node.'''
        pass

    def addAttribute(self, node, attribute, type): 
        '''addAttribute(self, node, attribute, type)
Arguments:
	[in]	node = MObject
	[in]	attribute = MObject
	[in]	type = MFnDependencyNode.MAttrClass

Add a new dynamic attribute to the given dependency node. The
 type  parameter allows the attribute to be added to a
particular node, or the whole class of nodes.'''
        pass

    def renameNode(self, node, newName): 
        '''renameNode(self, node, newName)
Arguments:
	[in]	node = MObject
	[in]	newName = MString

This method adds an operation to this dependency graph modifier
that will rename a dependency graph node.'''
        pass

    def newPlugValue(self, plug, plugValue): 
        '''newPlugValue(self, plug, plugValue)
Arguments:
	[in]	plug = MPlug
	[in]	plugValue = MObject

Adds an operation to this dependency graph modifier that sets a
plug value. Plug values can be created with the  MFnNumericData  class.'''
        pass

    def connect(self, source, dest): 
        '''connect(self, source, dest)
Arguments:
	[in]	source = MPlug
	[in]	dest = MPlug

Adds an operation to this dependency graph modifier that
connects two plugs in the dependency graph. The value of the
destination plug is supplied by the value of the source plug once
they are connected.'''
        pass

    def undoIt(self): 
        '''undoIt(self)
Undoes all of the operations that have been given to this
modifier. It is only valid to call this method after the doIt
method has been called.'''
        pass

    def commandToExecute(self, command): 
        '''commandToExecute(self, command)
Arguments:
	[in]	command = MString

Adds an operation to this dependency graph modifier that
executes a MEL command. The specified command must be undoable
otherwise unexepected results may occur.'''
        pass

class MEulerRotation:
    '''Euler Rotation Math.'''
    def __init__(self):
        pass


    identity = ''
    '''The euler rotation identity. The rotation
order is XYZ.'''

    def asQuaternion(self): 
        '''asQuaternion(self) -> MQuaternion

Converts an euler rotation to a quaternion.'''
        pass

    def bound(self): 
        '''bound(self) -> MEulerRotation

Returns the result of bounding this rotation to be within +/-
PI. Bounding a rotation to be within +/- PI is defined to be the
result of offsetting the rotation by +/- 2nPI (term by term) such
that the offset is within +/- PI.'''
        pass

    def __radd__(self, other): 
        '''__radd__(self, other) -> MEulerRotation
Returns: Returns:
A reference the euler rotation which has been added to the
other euler rotation

Arguments:
	[in]	other = MEulerRotation

The in place euler rotation addition operator.'''
        pass

    def __rsub__(self, other): 
        '''__rsub__(self, other) -> MEulerRotation
Returns: Returns:
A reference the euler rotation which has had the other euler
rotation subtracted from it

Arguments:
	[in]	other = MEulerRotation

The in place euler rotation subtraction operator.'''
        pass

    def reorderIt(self, ord): 
        '''reorderIt(self, ord) -> MEulerRotation
Returns: Returns:
A reference to the euler rotation that has been reordered

Arguments:
	[in]	ord = MEulerRotation.RotationOrder

Performs an in place reordering of this euler rotation, such
that the euler rotation will have the specified rotation order.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:


true the euler rotations are not identical
false the euler rotations are identical

Arguments:
	[in]	other = MEulerRotation

The euler rotation inequality operator.'''
        pass

    def closestCut(self, dst): 
        '''closestCut(self, dst) -> MEulerRotation
Returns: Returns:
The closest cut of this rotation

Arguments:
	[in]	dst = MEulerRotation

Returns the closest cut of this rotation to "dst". The closest
cut of rotation A to rotation B is defined to be the rotation that
is +/- 2nPI to rotation A (term by term) and within +/- PI to
rotation B.'''
        pass

    def inverse(self): 
        '''inverse(self) -> MEulerRotation

Returns the inverse of this euler rotation. The rotation order
will be reversed.'''
        pass

    def incrementalRotateBy(self, axis, angle): 
        '''incrementalRotateBy(self, axis, angle) -> MEulerRotation
Returns: Returns:
A reference to the euler rotation that has been incrementally
rotated

Arguments:
	[in]	axis = MVector
	[in]	angle = double

Perform an incremental rotation by the specified axis and angle.
The rotation is broken down and performed in smaller steps so that
the angles update properly.'''
        pass

    def setToAlternateSolution(self): 
        '''setToAlternateSolution(self) -> MEulerRotation

Sets this euler rotation to an alternate solution of this
rotation. The resulting rotation will be bound between +/- PI, and
the rotation order will remain unchanged.'''
        pass

    def isZero(self, tolerance): 
        '''isZero(self, tolerance) -> bool
Returns: Returns:


true the rotation is zero
false the rotation is not zero

Arguments:
	[in]	tolerance = double

This method returns true if this euler rotation is zero, within
some given tolerance.'''
        pass

    def asMatrix(self): 
        '''asMatrix(self) -> MMatrix

Converts an euler rotation to a rotation matrix.'''
        pass

    def reorder(self, ord): 
        '''reorder(self, ord) -> MEulerRotation
Returns: Returns:
Euler rotation that is the reordering of this euler
rotation

Arguments:
	[in]	ord = MEulerRotation.RotationOrder

Returns the reordering of this euler rotation, such that the
euler rotation will have the specified rotation order.'''
        pass

    def boundIt(self): 
        '''boundIt(self) -> MEulerRotation

Bounds this rotation to be within +/- PI. Bounding a rotation to
be within +/- PI is defined to be the result of offsetting the
rotation by +/- 2nPI (term by term) such that the offset is within
+/- PI.'''
        pass

    def setValue(self, xx, yy, zz, ord): 
        '''setValue(self, xx, yy, zz, ord) -> MEulerRotation
Returns: Returns:
A reference to the euler rotation whose value has been set

Arguments:
	[in]	xx = double
	[in]	yy = double
	[in]	zz = double
	[in]	ord = MEulerRotation.RotationOrder

Sets the euler rotation to the x, y, and z rotation components
with the specified rotation order.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double
Returns: Returns:
The component of the euler rotation corresponding to the
index

Arguments:
	[in]	i = int

The index operator. If its argument is 0 it will return the x
component of the euler rotation. If its argument is 1 it will
return the y component of the euler rotation. If its argument is 2
it will return the z component of the euler rotation.'''
        pass

    def asVector(self): 
        '''asVector(self) -> MVector

Converts an euler rotation to a vector. The rotation order
component is dropped.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: Returns:


true the euler rotations are equivalent
false the euler rotations are not equivalent

Arguments:
	[in]	other = MEulerRotation
	[in]	tolerance = double

This method returns true if this euler rotation is equivalent,
within some given tolerance, to the other euler rotation.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MEulerRotation
Returns: Returns:
The sum of the two euler rotations

Arguments:
	[in]	other = MEulerRotation

The euler rotation addition operator.'''
        pass

    def setToClosestSolution(self, dst): 
        '''setToClosestSolution(self, dst) -> MEulerRotation
Returns: Returns:
A reference to the euler rotation that has been set to the
closest solution

Arguments:
	[in]	dst = MEulerRotation

Sets this euler rotation to the euler rotation that is the
closest solution to the "dst" euler rotation.'''
        pass

    def invertIt(self): 
        '''invertIt(self) -> MEulerRotation

Performs an in place inversion of this euler rotation. The
rotation order will be reversed.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:


true the euler rotations are identical
false the euler rotations are not identical

Arguments:
	[in]	other = MEulerRotation

The euler rotation equality operator.'''
        pass

    def alternateSolution(self): 
        '''alternateSolution(self) -> MEulerRotation

Returns an alternate solution to this rotation. The resulting
rotation will be bound between +/- PI, and the rotation order will
remain unchanged.'''
        pass

    def closestSolution(self, dst): 
        '''closestSolution(self, dst) -> MEulerRotation
Returns: Returns:
The closest solution to the "dst" rotation

Arguments:
	[in]	dst = MEulerRotation

Returns the euler rotation that is the closest solution to the
"dst" euler rotation.'''
        pass

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

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

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

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

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

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

    class RotationOrder:
        '''Non-functional class.  Values for this enum:
        kZYX
        kZXY
        kXYZ
        kYZX
        kYXZ
        kXZY
'''
        def __init__(self):
            pass

    def __rmult__(self, other): 
        '''__rmult__(self, other) -> MEulerRotation
Returns: Returns:
A reference to the euler rotation which has been multiplied
with the double

Arguments:
	[in]	other = double

The in place scalar multiplication operator.'''
        pass

    def setToClosestCut(self, dst): 
        '''setToClosestCut(self, dst) -> MEulerRotation
Returns: Returns:
A reference to the euler rotation that has been set to the
closest cut

Arguments:
	[in]	dst = MEulerRotation

Sets this rotation to be the closest cut to "dst". The closest
cut of rotation A to rotation B is defined to be the rotation that
is +/- 2nPI to rotation A (term by term) and within +/- PI to
rotation B.'''
        pass

    def __mul__(self, other): 
        '''__mul__(self, other) -> MEulerRotation
Returns: Returns:
The product of the euler rotation and the scalar value

Arguments:
	[in]	other = double

This scalar multiplication operator.'''
        pass

    def __sub__(self): 
        '''__sub__(self) -> MEulerRotation

The unary minus operator. Negates the value of each of the x, y,
and z components of the euler rotation. The order remains the
same.'''
        pass

    def decompose(self, matrix, ord): 
        '''decompose(self, matrix, ord) -> MEulerRotation
Returns: Returns:
The euler rotation that has been decomposed from the rotation
matrix

Arguments:
	[in]	matrix = MMatrix
	[in]	ord = MEulerRotation.RotationOrder

Decompose a rotation matrix into the desired euler angles with
the specified order.'''
        pass

class MEventMessage:
    '''Event messages.'''
    def __init__(self):
        pass


    def getEventNames(self, names): 
        '''getEventNames(self, names)
Arguments:
	[out]	names = MStringArray

This method returns the list of available event names.'''
        pass

    def addEventCallback(self, eventName, func, clientData): 
        '''addEventCallback(self, eventName, func, clientData) -> MCallbackId

Arguments:
	[in]	eventName = MString
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

This method registers a callback for event occurred
messages.'''
        pass

class MFileIO:
    '''I/O operations on scene files.'''
    def __init__(self):
        pass


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

Return the name of the file currently being loaded.'''
        pass

    def getFiles(self, wantUnresolvedNames, wantReferencesOnly, files): 
        '''getFiles(self, wantUnresolvedNames, wantReferencesOnly, files)
Arguments:
	[out]	files = MStringArray
	[in]	wantUnresolvedNames = bool
	[in]	wantReferencesOnly = bool

Return an array of all the files used by the currently active
scene. Includes file references, file textures, cache files, image
planes etc.'''
        pass

    def getErrorStatus(self): 
        '''getErrorStatus(self) -> bool
Returns: Returns:
Boolean value indicating the error status.

Returns the error status of the last file read. Returns true if
any error occurred during the last file read, else false is
returned.'''
        pass

    def importFile(self, fileName, type, preserveReferences, nameSpace): 
        '''importFile(self, fileName, type, preserveReferences, nameSpace)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	preserveReferences = bool
	[in]	nameSpace = char

Import the scene elements from the given file into the current
scene. This operation is similar to open, but instead of replacing
the current scene with the one from the new file, it adds the
elements from that file to the existing ones in the current
scene.'''
        pass

    def beforeOpenFilename(self): 
        '''beforeOpenFilename(self) -> MString
Returns: Returns:
The name of the file to be opened

Retrieves the name of the file requested to be opened. This name
can be retrieved from within the beforeOpenCheck and beforeOpen
callback functions (that must be registered using  MSceneMessage::addCallback() 
before the file is attempted to be opened). If called outside of
these two callback functions the results are undefined.'''
        pass

    def reference(self, fileName, deferReference, lockReference): 
        '''reference(self, fileName, deferReference, lockReference)
Arguments:
	[in]	fileName = MString
	[in]	deferReference = bool
	[in]	lockReference = bool

Add the given filename as a reference from the current file.
When a new file is opened, the contents of any files it references
are read into the scene, however maya remembers that the elements
came from the referenced file, and does not write them during a
save operation. Instead the reference is written so the contents of
the referenced file (which might have changed) will be read again
when the scene is reloaded.'''
        pass

    def setCurrentFile(self, fileName): 
        '''setCurrentFile(self, fileName)
Arguments:
	[in]	fileName = MString

Set the name of the current active scene.'''
        pass

    def beforeImportFilename(self): 
        '''beforeImportFilename(self) -> MString
Returns: Returns:
The name of the file to be imported

Retrieves the name of the file requested to be imported. This
name can be retrieved from within the beforeImportCheck and
beforeImport callback functions (that must be registered using
 MSceneMessage::addCallback() 
before the file is attempted to be imported). If called outside of
these two callback functions the results are undefined.'''
        pass

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

Determine if Maya is currently in the middle of a file read
operation.'''
        pass

    def cleanReference(self, referenceNodeName, editCommand): 
        '''cleanReference(self, referenceNodeName, editCommand)
Arguments:
	[in]	referenceNodeName = MString
	[in]	editCommand = char

This function removes the edits from the passed in reference
node. The reference must be in an unloaded state.'''
        pass

    def loadReferenceByNode(self, referenceNode): 
        '''loadReferenceByNode(self, referenceNode) -> MString
Returns: Returns:
The name of the loaded reference file

Arguments:
	[in]	referenceNode = MObject

Loads the reference, referenced by the given reference node
object.'''
        pass

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

Determine if Maya is currently in the middle of a file import
operation.'''
        pass

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

Determine if Maya is currently in the middle of a file write
operation.'''
        pass

    def exportAsReference(self, fileName, type): 
        '''exportAsReference(self, fileName, type)
Arguments:
	[in]	fileName = MString
	[in]	type = char

Export the selected objects into a reference file.'''
        pass

    def mustRenameToSaveMsg(self): 
        '''mustRenameToSaveMsg(self) -> MString
Returns: Returns:
The error message to display.

This method returns a string that is displayed when a user
attempts to save a scene that was set to not overwrite itself. See
the  MFileIO::setMustRenameToSave() 
documentation.'''
        pass

    def exportSelectedAnimFromReference(self, fileName, refNodeName, type): 
        '''exportSelectedAnimFromReference(self, fileName, refNodeName, type)
Arguments:
	[in]	fileName = MString
	[in]	refNodeName = MString
	[in]	type = char

Export the selected animation from reference, to the specified
file.'''
        pass

    def beforeSaveUserFileTranslator(self): 
        '''beforeSaveUserFileTranslator(self) -> MPxFileTranslator
Returns: Returns:
A pointer to the file translator being used for file save, or
NULL.

Retrieves the plug-in-defined file translator being used for
file save, if any. If a standard Maya file translator (e.g.
mayaAscii) is being used, returns NULL. The translator can be
retrieved from within the beforeSaveCheck and beforeSave callback
functions (that must be registered using  MSceneMessage::addCallback() 
before the file is attempted to be saved). If called outside of
these two callback functions the results are undefined.'''
        pass

    def getFileTypes(self, types): 
        '''getFileTypes(self, types)
Arguments:
	[out]	types = MStringArray

Returns an array of all the valid type names that Maya currently
supports. Only elements from this list are valid arguments for the
 type  arguments to  open ,  saveAs ,  import ,
 exportSelected , and  exportAll .'''
        pass

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

Determine if Maya is currently performing a "new" operation.'''
        pass

    def open(self, fileName, type, force, refMode, ignoreVersion): 
        '''open(self, fileName, type, force, refMode, ignoreVersion)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	force = bool
	[in]	refMode = MFileIO.ReferenceMode
	[in]	ignoreVersion = bool

Open the given file, and set the current active scene to this
file. If there are unsaved changes in the current scene, this
operation will fail unless the force flag is set to true.'''
        pass

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

Return the type of the current active scene.'''
        pass

    def getLastTempFile(self): 
        '''getLastTempFile(self) -> MString
Returns: Returns:
The name of the temp file

Returns the temp file used during file save.'''
        pass

    def getReferenceConnectionsBroken(self, node, append, removeDuplicates, srcPlugs, destPlugs): 
        '''getReferenceConnectionsBroken(self, node, append, removeDuplicates, srcPlugs, destPlugs)
Arguments:
	[in]	node = MObject
	[out]	srcPlugs = MPlugArray
	[out]	destPlugs = MPlugArray
	[in]	append = bool
	[in]	removeDuplicates = bool

Returns arrays of source and destination plugs corresponding to
the broken connections from referenced files, where those
connections involved the specified node.'''
        pass

    def saveReference(self, referenceFileName): 
        '''saveReference(self, referenceFileName)
Arguments:
	[in]	referenceFileName = MString

This function saves reference node edits and connections to
reference file'''
        pass

    def loadReference(self, referenceFileName): 
        '''loadReference(self, referenceFileName) -> MString
Returns: Returns:
The name of the loaded reference file

Arguments:
	[in]	referenceFileName = MString

Loads the reference, referenced by the given reference node name
and file name.'''
        pass

    def unloadReference(self, referenceFileName): 
        '''unloadReference(self, referenceFileName) -> MString
Returns: Returns:
The name of the unloaded reference file

Arguments:
	[in]	referenceFileName = MString

Unloads the reference, referenced by the given reference node
and file.'''
        pass

    def save(self, force): 
        '''save(self, force)
Arguments:
	[in]	force = bool

Save the contents of the current scene. If there have been no
changes to the scene since the last save, then this operation will
succeed, but not actually rewrite the save file unless the force
flag is set to true.'''
        pass

    def beforeImportUserFileTranslator(self): 
        '''beforeImportUserFileTranslator(self) -> MPxFileTranslator
Returns: Returns:
A pointer to the file translator being used to import, or
NULL.

Retrieves the plug-in-defined file translator being used for
import, if any. If a standard Maya file translator (e.g. mayaAscii)
is being used, returns NULL. The translator can be retrieved from
within the beforeImportCheck and beforeImport callback functions
(that must be registered using  MSceneMessage::addCallback() 
before the file is attempted to be imported). If called outside of
these two callback functions the results are undefined.'''
        pass

    def exportAnim(self, fileName, type): 
        '''exportAnim(self, fileName, type)
Arguments:
	[in]	fileName = MString
	[in]	type = char

Export animation to the specified file.'''
        pass

    def beforeReferenceFilename(self): 
        '''beforeReferenceFilename(self) -> MString
Returns: Returns:
The name of the file to be referenced

Retrieves the name of the file requested to be referenced. This
name can be retrieved from within the beforeRefenceCheck and
beforeRefence callback functions (that must be registered using
 MSceneMessage::addCallback() 
before the file is attempted to be referenced). If called outside
of these two callback functions the results are undefined.'''
        pass

    def saveAs(self, fileName, type, force): 
        '''saveAs(self, fileName, type, force)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	force = bool

Save the contents of the current scene to the given file. If
there have been no changes to the scene since the last save, then
this operation will succeed, but not actually rewrite the save file
unless the force flag is set to true.'''
        pass

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

Determine if Maya is currently performing a file open
operation.'''
        pass

    def beforeExportFilename(self): 
        '''beforeExportFilename(self) -> MString
Returns: Returns:
The name of the file to be exported

Retrieves the name of the file requested to be exported. This
name can be retrieved from within the beforeExportCheck and
beforeExport callback functions (that must be registered using
 MSceneMessage::addCallback() 
before the file is attempted to be exported). If called outside of
these two callback functions the results are undefined.'''
        pass

    def mustRenameToSave(self): 
        '''mustRenameToSave(self) -> bool
Returns: Returns:
true if this file must be renamed before saving.

Scenes may be flagged as needing to be renamed before saving.
The purpose is to prevent overwriting the original file, which may
have had a significant change. Users will need to use save as to
save the scene with a different file name.'''
        pass

    def getReferences(self, wantUnresolvedNames, references): 
        '''getReferences(self, wantUnresolvedNames, references)
Arguments:
	[out]	references = MStringArray
	[in]	wantUnresolvedNames = bool

Return an array of all the files referenced from the currently
active scene.'''
        pass

    def beforeOpenUserFileTranslator(self): 
        '''beforeOpenUserFileTranslator(self) -> MPxFileTranslator
Returns: Returns:
A pointer to the file translator being used for file open, or
NULL.

Retrieves the plug-in-defined file translator being used for
file open, if any. If a standard Maya file translator (e.g.
mayaAscii) is being used, returns NULL. The translator can be
retrieved from within the beforeOpenCheck and beforeOpen callback
functions (that must be registered using  MSceneMessage::addCallback() 
before the file is attempted to be opened). If called outside of
these two callback functions the results are undefined.'''
        pass

    def kLoadAllReferences(self):
        '''This is an enum of ReferenceMode.
Description: Load all references in the scene.
Value: 1'''
        pass

    def kLoadNoReferences(self):
        '''This is an enum of ReferenceMode.
Description: Don't load any references.
Value: 2'''
        pass

    def kLoadDefault(self):
        '''This is an enum of ReferenceMode.
Description: Load references that were loaded when scene was saved.
Value: 0'''
        pass

    class ReferenceMode:
        '''Non-functional class.  Values for this enum:
        kLoadAllReferences
        kLoadNoReferences
        kLoadDefault
'''
        def __init__(self):
            pass

    def getReferenceConnectionsMade(self, fileName, connections): 
        '''getReferenceConnectionsMade(self, fileName, connections)
Arguments:
	[in]	fileName = MString
	[out]	connections = MStringArray

Return an array of attribute pairs representing connections made
to nodes in the given referenced file. The first element of the
pair is the source attribute in the connection, and the second is
the destination. These pairs correspond to the "connectAttr"
statements in a scene file where changes to the referenced file
occur after the referenced file has been opened.'''
        pass

    def getReferenceNodes(self, fileName, list): 
        '''getReferenceNodes(self, fileName, list)
Arguments:
	[in]	fileName = MString
	[out]	list = MSelectionList

Return an array of all the nodes referenced by the given
filename.'''
        pass

    def beforeExportUserFileTranslator(self): 
        '''beforeExportUserFileTranslator(self) -> MPxFileTranslator
Returns: Returns:
A pointer to the file translator being used to export, or
NULL.

Retrieves the plug-in-defined file translator being used for
export, if any. If a standard Maya file translator (e.g. mayaAscii)
is being used, returns NULL. The translator can be retrieved from
within the beforeExportCheck and beforeExport callback functions
(that must be registered using  MSceneMessage::addCallback() 
before the file is attempted to be exported). If called outside of
these two callback functions the results are undefined.'''
        pass

    def setMustRenameToSaveMsg(self, errorMsg): 
        '''setMustRenameToSaveMsg(self, errorMsg)
Arguments:
	[in]	errorMsg = MString

This method sets a string that is displayed when a user attempts
to save a scene that was set to not overwrite itself. See the
 MFileIO::setMustRenameToSave() 
documentation.'''
        pass

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

Return the name of the currently active scene.'''
        pass

    def exportSelected(self, fileName, type, preserveReferences): 
        '''exportSelected(self, fileName, type, preserveReferences)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	preserveReferences = bool

Export all currently selected scene elements to the given
file.'''
        pass

    def getReferenceFileByNode(self, referenceNode): 
        '''getReferenceFileByNode(self, referenceNode) -> MString
Returns: Returns:
The name of the reference file, containing the given node.

Arguments:
	[in]	referenceNode = MObject

Returns the name of the reference file, which contains the given
reference node.'''
        pass

    def setMustRenameToSave(self, rename): 
        '''setMustRenameToSave(self, rename)
Arguments:
	[in]	rename = bool

This method enabled or disables a state where the current Maya
scene must save to a different file name. This can be used to
prevent a user from overwriting the original scene if a
particularly dangerous or experimental change was made.'''
        pass

    def exportAnimFromReference(self, fileName, refNodeName, type): 
        '''exportAnimFromReference(self, fileName, refNodeName, type)
Arguments:
	[in]	fileName = MString
	[in]	refNodeName = MString
	[in]	type = char

Export the animation from the specified reference node, to the
specified file.'''
        pass

    def exportSelectedAnim(self, fileName, type): 
        '''exportSelectedAnim(self, fileName, type)
Arguments:
	[in]	fileName = MString
	[in]	type = char

Export selected animation to the specified file.'''
        pass

    def beforeSaveFilename(self): 
        '''beforeSaveFilename(self) -> MString
Returns: Returns:
The name of the file to be saved

Retrieves the name of the file requested to be saved. This name
can be retrieved from within the beforeSaveCheck and beforeSave
callback functions (that must be registered using  MSceneMessage::addCallback() 
before the file is attempted to be saved). If called outside of
these two callback functions the results are undefined.'''
        pass

    def removeReference(self, fileName): 
        '''removeReference(self, fileName)
Arguments:
	[in]	fileName = MString

Remove the named file as a reference from the current file.'''
        pass

    def newFile(self, force): 
        '''newFile(self, force)
Arguments:
	[in]	force = bool

Set everything back to a new file state.'''
        pass

    def beforeReferenceUserFileTranslator(self): 
        '''beforeReferenceUserFileTranslator(self) -> MPxFileTranslator
Returns: Returns:
A pointer to the file translator being used for file reference,
or NULL.

Retrieves the plug-in-defined file translator being used for
file reference, if any. If a standard Maya file translator (e.g.
mayaAscii) is being used, returns NULL. The translator can be
retrieved from within the beforeRefenceCheck and beforeRefence
callback functions. (that must be registered using  MSceneMessage::addCallback() 
before the file is attempted to be referenced). If called outside
of these two callback functions the results are undefined.'''
        pass

    def unloadReferenceByNode(self, referenceNode): 
        '''unloadReferenceByNode(self, referenceNode) -> MString
Returns: Returns:
The name of the unloaded reference file

Arguments:
	[in]	referenceNode = MObject

Unloads the reference, referenced by the given reference
node.'''
        pass

    def exportAll(self, fileName, type, preserveReferences): 
        '''exportAll(self, fileName, type, preserveReferences)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	preserveReferences = bool

Export the current scene to the given file.'''
        pass

    def resetError(self): 
        '''resetError(self)
Resets the error.'''
        pass

class MFileObject:
    '''Manipulate Unix filenames and search paths.'''
    def __init__(self):
        pass


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

Returns the unresolved filename element of the  MFileObject .'''
        pass

    def ithFullName(self, index): 
        '''ithFullName(self, index) -> MString
Returns: Returns:
The pathname.

Arguments:
	[in]	index = int

Returns the pathname of a file constructed from the indicated
portion of the path element and filename element. All variables in
the path element are expanded, and the indicated path portion is
prepended to the filename element to construct the fullName.'''
        pass

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

Returns the number of paths in the path element of the  MFileObject . This
will be equal to one more than the number of ':' characters
specified by the setRawPath method.'''
        pass

    def setRawPath(self, pathName): 
        '''setRawPath(self, pathName)
Arguments:
	[in]	pathName = MString

Set the unresolved path element of the  MFileObject 
instance. This should contain a list of directories, each separated
by a single ':' character. The pathnames can contain Unix
environment variables in the form $VARNAME. These will be expanded
when paths to actual filenames are constructed.'''
        pass

    def exists(self, index): 
        '''exists(self, index) -> bool
Returns: Returns:
true if the file exists and is readable, false
otherwise.

Arguments:
	[in]	index = int

Checks to see if the file constructed from the indicated portion
of the path element and filename element exists and is readble.'''
        pass

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

Returns the path element of the  MFileObject  with
all environment variables unexpanded.'''
        pass

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

Checks to see if both file and path elements of the  MFileObject  have
been set.'''
        pass

    def setRawFullName(self, fullFileName): 
        '''setRawFullName(self, fullFileName)
Arguments:
	[in]	fullFileName = MString

This method combines the functions of the setRawName and
setRawPath methods in that it sets both the path and filename from
the given name.'''
        pass

    def setRawName(self, fileName): 
        '''setRawName(self, fileName)
Arguments:
	[in]	fileName = MString

Set the unresolved filename element of the  MFileObject 
instance. This name should not contain any '/' characters, it
should indicate simply the name of a file. The directories in which
this name will be searched for are specified by setRawPath.'''
        pass

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

Returns the unresolved full file name (path plus filename) of
the  MFileObject  with
all environment variables unexpanded.'''
        pass

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

Returns the first pathname of a file constructed from the path
and filename elements. All variables in the path element are
expanded, and the first path (the part before the first ':' in the
path) is prepended to the filename element to construct the
fullName.'''
        pass

    def overrideResolvedFullName(self, fullFileName): 
        '''overrideResolvedFullName(self, fullFileName)
Arguments:
	[in]	fullFileName = MString

Normally when a raw file name is set, Maya will perform a series
of operations on it in an attempt to resolve it to a valid file
name. This final resolved file name can be accessed through the
 MFileObject::resolvedName() ,
 MFileObject::resolvedPath() ,
and MFileObject::resolvedFullFileName() methods and can be quite
different from the originally specified raw file name.'''
        pass

    def setResolveMethod(self, method): 
        '''setResolveMethod(self, method)
Arguments:
	[in]	method = MFileObject.MFileResolveMethod

Set the steps that should be used to resolve this file path.'''
        pass

    def kReferenceMappings(self):
        '''This is an enum of MFileResolveMethod.
Description: Check path against any previously re-mapped reference
locations. If kRelative/kBaseName are set, then even if we have an
absolute path, convert to relative and/or baseName and look for
them in directories provided to the missing reference dialog.
Value: 8'''
        pass

    def kRelative(self):
        '''This is an enum of MFileResolveMethod.
Description: Strips away the project directory, and treats path as relative.
Relative to the current workspace, that is. So look in the
workspace current directory, file-rules directory and the root
directory
Value: 16'''
        pass

    def kInputReference(self):
        '''This is an enum of MFileResolveMethod.
Description: Default on file reference.
Value: 62'''
        pass

    def kBaseName(self):
        '''This is an enum of MFileResolveMethod.
Description: Strips away everything but the base file name and look in the
current workspace.
Value: 32'''
        pass

    def kDirMap(self):
        '''This is an enum of MFileResolveMethod.
Description: Checks path against mappings defined with the dirmap command.
Only for absolute paths.
Value: 4'''
        pass

    def kStrict(self):
        '''This is an enum of MFileResolveMethod.
Description: Equivalent to the file -strict flag.
Value: 6'''
        pass

    def kInputFile(self):
        '''This is an enum of MFileResolveMethod.
Description: Default on file open and import.
Value: 54'''
        pass

    def kExact(self):
        '''This is an enum of MFileResolveMethod.
Description: Checks if expanded paths exist. If paths are relative, assume
it's relative to the current workspace (so check workspace current
directory, file-rule directory and root directory
Value: 2'''
        pass

    def kNone(self):
        '''This is an enum of MFileResolveMethod.
Description: (Default) The resolved path is simply the first path after
expanding any environment variables. Will not check if this file
actually exists. User must explicitly check
Value: 1'''
        pass

    class MFileResolveMethod:
        '''Non-functional class.  Values for this enum:
        kReferenceMappings
        kRelative
        kInputReference
        kBaseName
        kDirMap
        kStrict
        kInputFile
        kExact
        kNone
'''
        def __init__(self):
            pass

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

Returns the resolved path element of the  MFileObject . In
order to build the resolved path, Maya first expands all
environment variables and then may perform additional
modifications, such as prepending directories to a relative path
name, in order to resolve the path to a valid location on disk.'''
        pass

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

Returns the path element of the  MFileObject  with
all environment variables expanded.'''
        pass

    def ithPath(self, index): 
        '''ithPath(self, index) -> MString
Returns: Returns:
The path element.

Arguments:
	[in]	index = int

Returns the indicated portion of the path element of the
 MFileObject . All
variables in the path element are expanded, and the portion
indicated by the argument is extracted and returned.'''
        pass

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

Returns the first pathname of a file constructed from the path
and filename elements. All variables in the path element are
expanded, and the first path (the part before the first ':' in the
path) is prepended to the filename element. After expanding all
environment variables Maya may then perform additional
modifications, such as prepending directories to a relative path
name, in order to resolve the path to a valid location on disk.'''
        pass

    def resolveMethod(self): 
        '''resolveMethod(self) -> MFileObject.MFileResolveMethod

Returns the file-path resolution steps this object will use'''
        pass

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

Returns the resolved filename element of the  MFileObject .'''
        pass

class MFloatArray:
    '''Array of floats data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = float
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = double
	[in]	index = int

Sets the value of the indicated element to the indicated double
value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = double

Copy the elements of the array into the given C++ array of
doubles. No checking is done to ensure that the destination C++
array of doubles is large enough to hold all the elements of the
instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MFloatArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = float

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MFloatMatrix:
    '''A matrix math class for 4x4 matrices of floats.'''
    def __init__(self):
        pass


    def setToIdentity(self): 
        '''setToIdentity(self) -> MFloatMatrix

Set this instance to the 4x4 identity matrix.'''
        pass

    def inverse(self): 
        '''inverse(self) -> MFloatMatrix

Compute and return the inverse of this instance.'''
        pass

    def setToProduct(self, left, right): 
        '''setToProduct(self, left, right) -> MFloatMatrix
Returns: Returns:
A reference to the result.

Arguments:
	[in]	left = MFloatMatrix
	[in]	right = MFloatMatrix

Set this instance to the inner product of the two argument
matrices.'''
        pass

    def homogenize(self): 
        '''homogenize(self) -> MFloatMatrix

Compute and return a homogenized version of this instance.'''
        pass

    def __getitem__(self, row): 
        '''__getitem__(self, row) -> float*
Returns: Returns:


float array containing the values of the specified row

Arguments:
	[in]	row = int

Index operator. Returns an entire row of the matrix as an array
of floats.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4

Fill a 4x4 matrix of floats with the elements from the
instance.'''
        pass

    def __rmult__(self, factor): 
        '''__rmult__(self, factor) -> MFloatMatrix
Returns: Returns:
A reference to the result.

Arguments:
	[in]	factor = float

The in place matrix multiply by a scalar operator.'''
        pass

    def adjoint(self): 
        '''adjoint(self) -> MFloatMatrix

Compute and return the adjoint of this instance.'''
        pass

    def det4x4(self): 
        '''det4x4(self) -> float

Compute and return the determinant of this instance.'''
        pass

    def transpose(self): 
        '''transpose(self) -> MFloatMatrix

Compute and return the transpose of this instance.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: Returns:
True if the matrices are equivalent and false otherwise

Arguments:
	[in]	other = MFloatMatrix
	[in]	tolerance = float

Determine if the given matrix is equivalent to this instance
within the specified tolerance.'''
        pass

    def __radd__(self, right): 
        '''__radd__(self, right) -> MFloatMatrix
Returns: Returns:
A reference to the result.

Arguments:
	[in]	right = MFloatMatrix

The in place matrix addition operator.'''
        pass

    def det3x3(self): 
        '''det3x3(self) -> float

Compute and return the determinant of the upper left 3x3
submatrix of this instance.'''
        pass

    def __rsub__(self, right): 
        '''__rsub__(self, right) -> MFloatMatrix
Returns: Returns:
A reference to the result.

Arguments:
	[in]	right = MFloatMatrix

The in place matrix subtraction operator.'''
        pass

    def __mul__(self, factor): 
        '''__mul__(self, factor) -> MFloatMatrix
Returns: Returns:
Scaled matrix.

Arguments:
	[in]	factor = float

The matrix multiply by a scalar operator.'''
        pass

    def __add__(self, right): 
        '''__add__(self, right) -> MFloatMatrix
Returns: Returns:
Sum of both matrices.

Arguments:
	[in]	right = MFloatMatrix

The matrix addition operator.'''
        pass

    def __sub__(self, right): 
        '''__sub__(self, right) -> MFloatMatrix
Returns: Returns:
Difference of both matrices.

Arguments:
	[in]	right = MFloatMatrix

The matrix subtraction operator.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
True is the matrices are identical.

Arguments:
	[in]	other = MFloatMatrix

The matrix equality operator.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:
True is the matrices are not identical.

Arguments:
	[in]	other = MFloatMatrix

The matrix inequality operator.'''
        pass

class MFloatPoint:
    '''Implementation of a point.'''
    def __init__(self):
        pass


    def rationalize(self): 
        '''rationalize(self) -> MFloatPoint

'''
        pass

   

    def homogenize(self): 
        '''homogenize(self) -> MFloatPoint

'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> float
Returns: Returns:
The value of the indicated component of the instance.

Arguments:
	[in]	i = int

The index operator.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4

Copy the values of x, y, z, and w from the instance to the four
elements of the given array of floats.'''
        pass

    def distanceTo(self, other): 
        '''distanceTo(self, other) -> float
Returns: Returns:
The distance between the two points.

Arguments:
	[in]	other = MFloatPoint

Return the distance between this instance and the point passed
as an argument.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MFloatPoint
Returns: Returns:
A point representing the product

Arguments:
	[in]	right = MFloatMatrix

The in-place multiplication operator for computing the product
of this point instance with the given matrix.'''
        pass

    def cartesianize(self): 
        '''cartesianize(self) -> MFloatPoint

'''
        pass

    def __div__(self, scale): 
        '''__div__(self, scale) -> MFloatPoint
Returns: Returns:
Scaled point.

Arguments:
	[in]	scale = float

The division operator that allows the vector to by scaled by the
given float parameter. The x, y, and z components are each divided
by the parameter. The w component remains unchanged.'''
        pass

    def __radd__(self, vector): 
        '''__radd__(self, vector) -> MFloatPoint

Arguments:
	[in]	vector = MFloatVector

The in-place addition operator for adding an  MFloatVector  to an
 MFloatPoint . The current instance
is translated from its original position by the vector.'''
        pass

    def setCast(self, d): 
        '''setCast(self, d)
Arguments:
	[in]	d = double4

Copy the values of x, y, z, and w to the instance from the four
elements of the given array of doubles. Note that this operation
will lose precision as it casts from double to single-precision
floating point.'''
        pass

    def __rsub__(self, vector): 
        '''__rsub__(self, vector) -> MFloatPoint

Arguments:
	[in]	vector = MFloatVector

The in-place subtraction operator for subtracting an  MFloatVector  from
an  MFloatPoint . The current instance
is translated from its original position by the inverse of the
vector.'''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> MFloatPoint
Returns: Returns:
A point representing the product

Arguments:
	[in]	right = MFloatMatrix

The multiplication operator for computing the product of this
point instance with the given matrix.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MFloatPoint

Arguments:
	[in]	other = MFloatVector

The operator for adding an  MFloatVector  to an
 MFloatPoint . A new point is
returned whose position is that of the original point translated by
the vector.'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: Returns:
True if the points are equal within the given tolerance and
false otherwise.

Arguments:
	[in]	other = MFloatPoint
	[in]	tol = float

Returns true if this instance the the point passed as an
argument represent the same position within the specified
tolerance.'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MFloatPoint

Arguments:
	[in]	other = MFloatVector

The operator for subtracting an  MFloatVector  from
an  MFloatPoint . A new point is
returned whose position is that of the original point translated by
the inverse of the vector.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool

Arguments:
	[in]	other = MFloatPoint

The equality operator. Returns true if all of the x, y, z, and w
components of the two points are identical.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool

Arguments:
	[in]	other = MFloatPoint

The inequality operator. Returns true if any of the x, y, z, and
w components of the two points are not identical.'''
        pass

class MFloatPointArray:
    '''Array of MFloatPoint data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MFloatPoint
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, val, index): 
        '''set(self, val, index)
Arguments:
	[in]	val = double4
	[in]	index = int

Sets the value of the indicated element to the indicated value.
The x component of the element is set to val[0], the y component to
val[1], the z component to val[2], and the w component to
val[3].'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MFloatPoint
Returns: Returns:
The value of the indicated element.

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = double

Copy the elements of the array into the C++ array of double
arrays. No checking is done to ensure that the destination C++
array of double arrays is large enough to hold all the elements of
the instance.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MFloatPointArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, x, y, z, w): 
        '''append(self, x, y, z, w)
Arguments:
	[in]	x = float
	[in]	y = float
	[in]	z = float
	[in]	w = float

Adds a new element to the end of the array. The appended element
has the indicated values for its x,y,z and w components. The x
component of the element is set to x, the y component to y, the z
component to z, and the w component to w.'''
        pass

class MFloatVector:
    '''A vector math class for vectors of floats.'''
    def __init__(self):
        pass


    yAxis = ''
    '''Unit vector in the positive y
direction.'''

    yNegAxis = ''
    '''Unit vector in the negative z
direction.'''

    zNegAxis = ''
    '''Unit vector in the negative z
direction.'''

    one = ''
    '''The vector <1.0,1.0,1.0>.'''

    xNegAxis = ''
    '''Unit vector in the negative z
direction.'''

    zero = ''
    '''The null vector.'''

    zAxis = ''
    '''Unit vector in the positive z
direction.'''

    xAxis = ''
    '''Unit vector in the positive x
direction.'''

    def normalize(self): 
        '''normalize(self)
Performs an in place normalization of the vector'''
        pass

    def angle(self, other): 
        '''angle(self, other) -> float
Returns: Returns:
The angle in radians

Arguments:
	[in]	other = MFloatVector

Returns the angle in radians between the vector and the one
passed as an argument.'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: Returns:
true if the vectors are equivalent and false otherwise

Arguments:
	[in]	other = MFloatVector
	[in]	tol = float

Returns true if the vector and the one passed as an argument are
equal to each other within the specified tolerance.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> float
Returns: Returns:
The vector component.

Arguments:
	[in]	i = int

The index operator. If its argument is 0 it will return the x
component of the vector. If its argument is 1 it will return the y
component of the vector. Otherwise it will return the z component
of the vector.'''
        pass

    def get(self, d): 
        '''get(self, d)
Arguments:
	[out]	d = float3

Extracts the x, y, and z components of the vector and places
them in elements 0, 1, and 2 of the float array passed.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MFloatVector

Arguments:
	[in]	right = MFloatMatrix

'''
        pass

    def normal(self): 
        '''normal(self) -> MFloatVector

Computes a unit vector aligned to the vector.'''
        pass

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

'''
        pass

    def __radd__(self, other): 
        '''__radd__(self, other) -> MFloatVector
Returns: Returns:
A reference to the resulting vector.

Arguments:
	[in]	other = MFloatVector

The in place vector addition operator.'''
        pass

    def isParallel(self, other, tol): 
        '''isParallel(self, other, tol) -> bool
Returns: Returns:
true if the vectors are parallel and false otherwise

Arguments:
	[in]	other = MFloatVector
	[in]	tol = float

Returns true if the current vector and the one passed as an
argument are parallel to each other within the specified
tolerance.'''
        pass

    def __div__(self, scalar): 
        '''__div__(self, scalar) -> MFloatVector
Returns: Returns:
The scaled vector.

Arguments:
	[in]	scalar = float

The division operator.'''
        pass

    def __rsub__(self, other): 
        '''__rsub__(self, other) -> MFloatVector
Returns: Returns:
A reference to the resulting vector.

Arguments:
	[in]	other = MFloatVector

The in place vector subtraction operator.'''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> float
Returns: Returns:
Dot product value.

Arguments:
	[in]	right = MFloatVector

The dot product operator.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MFloatVector
Returns: Returns:
The resulting vector.

Arguments:
	[in]	other = MFloatVector

The vector addition operator.'''
        pass

    def __rdiv__(self, scalar): 
        '''__rdiv__(self, scalar) -> MFloatVector
Returns: Returns:
A reference to the scaled vector.

Arguments:
	[in]	scalar = float

The in place division operator.'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MFloatVector
Returns: Returns:
The resulting vector.

Arguments:
	[in]	other = MFloatVector

The vector subtraction operator.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
Bool true if the vectors are identical and false
otherwise.

Arguments:
	[in]	other = MFloatVector

The vector equality operator. This returns true if all three of
the x, y, and z components are identical.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:
Bool false if the vectors are identical and true
otherwise.

Arguments:
	[in]	other = MFloatVector

The vector inequality operator. This returns false if all three
of the x, y, and z components are identical.'''
        pass

class MFloatVectorArray:
    '''Array of MFloatVectors data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MFloatVector
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = float3
	[in]	index = int

Sets the value of the indicated element to the indicated float
array value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MFloatVector
Returns: Returns:
The value of the indicated element.

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = float

Copy the elements of the array into the given C++ array of float
arrays. No checking is done to ensure that the destination C++
array of floats arrays is large enough to hold all the elements of
the instance.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MFloatVectorArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MFloatVector

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MFnAmbientLight:
    '''Manage Ambient Light dependency Nodes.'''
    def __init__(self):
        pass


    def setCastSoftShadows(self, cast_soft_shadows): 
        '''setCastSoftShadows(self, cast_soft_shadows)
Arguments:
	[in]	cast_soft_shadows = bool

Sets the value of the "castSoftShadows" attribute of an ambient
light node.'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool

Creates a new ambient light dependency graph node and adds it to
the dependency graph. If the UIvisible parameter is true, the new
node will be connected to the light classification node (which
allows the UI to recognize the node as a light) and added to the
default light list. If UIvisible is false, the node will be created
in isolation.'''
        pass

    def setAmbientShade(self, ambient_shade): 
        '''setAmbientShade(self, ambient_shade)
Arguments:
	[in]	ambient_shade = float

Sets the value of the "ambientShade" attribute of an ambient
light node.'''
        pass

    def ambientShade(self): 
        '''ambientShade(self) -> float
Returns: Returns:
The value of the "ambientShade" attribute of the ambient light
node.

Retrieves the value of the "ambientShade" attribute of an
ambient light node. This attribute determines how positional the
light is. A value of 0 represents a completely ambient light, while
a value of 1 represents a point light.'''
        pass

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

'''
        pass

    def setShadowRadius(self, shadow_radius): 
        '''setShadowRadius(self, shadow_radius)
Arguments:
	[in]	shadow_radius = float

Sets the value of the "shadowRadius" attribute of an ambient
light node.'''
        pass

    def shadowRadius(self): 
        '''shadowRadius(self) -> float
Returns: Returns:
The value of the "shadowRadius" attribute of the ambient light
node.

Retrieves the value of the "shadowRadius" attribute of an
ambient light node. This attribute represents the radius of the
light used when computing soft shadows. Higher radius values result
in more extended soft shadows.'''
        pass

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

'''
        pass

    def castSoftShadows(self): 
        '''castSoftShadows(self) -> bool
Returns: Returns:
The value of the "castSoftShadows" attribute of the ambient
light node.

Retrieves the value of the "castSoftShadows" attribute of an
ambient light node. This attribute determines whether or not the
light casts soft shadows.'''
        pass

class MFnAnisotropyShader:
    '''Manage anisotropic shaders.'''
    def __init__(self):
        pass


    def setTangentUCamera(self, tangu_camera): 
        '''setTangentUCamera(self, tangu_camera)
Arguments:
	[in]	tangu_camera = MColor

Sets the value of the "color" attribute of a shader node.'''
        pass

    def correlationX(self): 
        '''correlationX(self) -> float
Returns: Returns:
The value of the "spreadX" attribute of the shader node.

Retrieves the value of the "spreadX" attribute of a shader
node.'''
        pass

    def setCorrelationY(self, correl_y): 
        '''setCorrelationY(self, correl_y)
Arguments:
	[in]	correl_y = float

Sets the value of the "spreadY" attribute of a shader node.'''
        pass

    def setTangentVCamera(self, tangv_camera): 
        '''setTangentVCamera(self, tangv_camera)
Arguments:
	[in]	tangv_camera = MColor

Sets the value of the "transparency" attribute of a shader
node.'''
        pass

    def refractiveIndex(self): 
        '''refractiveIndex(self) -> float
Returns: Returns:
The value of the "fresnelRefractiveIndex" attribute of the
shader node.

Retrieves the value of the "fresnelRefractiveIndex" attribute of
a layered shader node.'''
        pass

    def correlationY(self): 
        '''correlationY(self) -> float
Returns: Returns:
The value of the "spreadY" attribute of the shader node.

Retrieves the value of the "spreadY" attribute of a shader
node.'''
        pass

    def tangentVCamera(self): 
        '''tangentVCamera(self) -> MColor
Returns: Returns:
The value of the "transparency" attribute of the shader
node.

Retrieves the value of the "transparency" attribute of a shader
node. This attribute represents the surface transparency of the
shader.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	UIvisible = bool

Creates a new layered shader dependency graph node and adds it
to the dependency graph. If the UIvisible parameter is true, the
new node will be connected to the shader classification node (which
allows the UI to recognize the node as a shader). If UIvisible is
false, the node will be created in isolation.'''
        pass

    def setRotateAngle(self, rotate_angle): 
        '''setRotateAngle(self, rotate_angle)
Arguments:
	[in]	rotate_angle = float

Sets the value of the "angle" attribute of a shader node.'''
        pass

    def setRefractiveIndex(self, refractive_index): 
        '''setRefractiveIndex(self, refractive_index)
Arguments:
	[in]	refractive_index = float

Sets the value of the "fresnelRefractiveIndex" attribute of a
shader node.'''
        pass

    def roughness(self): 
        '''roughness(self) -> float
Returns: Returns:
The value of the "roughness" attribute of the shader node.

Retrieves the value of the "roughness" attribute of a shader
node.'''
        pass

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

'''
        pass

    def anisotropicReflectivity(self): 
        '''anisotropicReflectivity(self) -> bool
Returns: Returns:
The value of the "anisotropicReflectivity" attribute of the
shader node.

Retrieves the value of the "anisotropicReflectivity" attribute
of a layered shader node.'''
        pass

    def setCorrelationX(self, correl_x): 
        '''setCorrelationX(self, correl_x)
Arguments:
	[in]	correl_x = float

Sets the value of the "spreadX" attribute of a shader node.'''
        pass

    def rotateAngle(self): 
        '''rotateAngle(self) -> float
Returns: Returns:
The value of the "angle" attribute of the shader node.

Retrieves the value of the "angle" attribute of a layered shader
node.'''
        pass

    def setAnisotropicReflectivity(self, anisotropic_reflectivity): 
        '''setAnisotropicReflectivity(self, anisotropic_reflectivity)
Arguments:
	[in]	anisotropic_reflectivity = bool

Sets the value of the "anisotropicReflectivity" attribute of a
shader node.'''
        pass

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

'''
        pass

    def setRoughness(self, roughness): 
        '''setRoughness(self, roughness)
Arguments:
	[in]	roughness = float

Sets the value of the "roughness" attribute of a shader
node.'''
        pass

    def tangentUCamera(self): 
        '''tangentUCamera(self) -> MColor
Returns: Returns:
The value of the "color" attribute of the shader node.

Retrieves the value of the "color" attribute of a shader node.
This attribute represents the surface color of the shader.'''
        pass

class MFnAreaLight:
    '''Manage Area Light dependency Nodes.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool

Creates a new area light dependency graph node and adds it to
the dependency graph. If the UIvisible parameter is true, the new
node will be connected to the light classification node (which
allows the UI to recognize the node as a light) and added to the
default light list. If UIvisible is false, the node will be created
in isolation.'''
        pass

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

'''
        pass

class MFnArrayAttrsData:
    '''Function set for multiple arrays of attributes for dependency node
data.'''
    def __init__(self):
        pass


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

Returns the number of attribute arrays.'''
        pass

    def doubleArray(self, name): 
        '''doubleArray(self, name) -> MDoubleArray
Returns: Returns:
A copy of the MDoubleArray held in this
instance

Arguments:
	[in]	name = MString

Return an  MDoubleArray  containing the
double array currently operated upon by the function set. The
 MDoubleArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set. If the array did not exist it
will be created.'''
        pass

    def getIntData(self, attrName): 
        '''getIntData(self, attrName) -> MIntArray
Returns: Returns:
A copy of the MIntArray held in this
instance

Arguments:
	[in]	attrName = MString

Return an  MIntArray  containing the int
array currently operated upon by the function set. The  MIntArray  returned by this
method is read only. If the array did not exist it will be
created.'''
        pass

    def getDoubleData(self, attrName): 
        '''getDoubleData(self, attrName) -> MDoubleArray
Returns: Returns:
A copy of the MDoubleArray held in this
instance

Arguments:
	[in]	attrName = MString

Return an  MDoubleArray  containing the
double array currently operated upon by the function set. The
 MDoubleArray  returned by this
method is read only. If the array did not exist it will be
created.'''
        pass

    def getVectorData(self, attrName): 
        '''getVectorData(self, attrName) -> MVectorArray
Returns: Returns:
A copy of the MVectorArray held in this
instance

Arguments:
	[in]	attrName = MString

Return an  MVectorArray  containing the
vector array currently operated upon by the function set. The
 MVectorArray  returned by this
method is read only. If the array did not exist it will be
created.'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: Invalid value.
Value: 0'''
        pass

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

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

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

    def kLast(self):
        '''This is an enum of Type.
Description: Last value. It does not represent real data, but can be used to
loop on all possible types
Value: 5'''
        pass

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

    class Type:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kIntArray
        kDoubleArray
        kVectorArray
        kLast
        kStringArray
'''
        def __init__(self):
            pass

    def clear(self): 
        '''clear(self)
Clear the contents of all of the arrays.'''
        pass

    def checkArrayExist(self, name, arrayType): 
        '''checkArrayExist(self, name, arrayType) -> bool
Returns: Returns:
True if the array exists and false otherwise.

Arguments:
	[in]	name = MString
	[out]	arrayType = MFnArrayAttrsData.Type

Check if the attribute array related to the given name has been
created. If the named array exists return true and the array data
type.'''
        pass

    def list(self): 
        '''list(self) -> MStringArray
Returns: Returns:
A list of all the names of all the arrays stored in the
data.

Returns a list of names for the attribute arrays.'''
        pass

    def getStringData(self, attrName): 
        '''getStringData(self, attrName) -> MStringArray
Returns: Returns:
A copy of the MStringArray held in this
instance

Arguments:
	[in]	attrName = MString

Return an  MStringArray  containing the
string array currently operated upon by the function set. The
 MStringArray  returned by this
method is read only. If the array did not exist it will be
created.'''
        pass

    def vectorArray(self, name): 
        '''vectorArray(self, name) -> MVectorArray
Returns: Returns:
A copy of the MVectorArray held in this
instance

Arguments:
	[in]	name = MString

Return an  MVectorArray  containing the
vector array currently operated upon by the function set. The
 MVectorArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set. If the array did not exist it
will be created.'''
        pass

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

'''
        pass

    def intArray(self, name): 
        '''intArray(self, name) -> MIntArray
Returns: Returns:
A copy of the MIntArray held in this
instance

Arguments:
	[in]	name = MString

Return an  MIntArray  containing the int
array currently operated upon by the function set. The  MIntArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set. If the array did not exist it
will be created.'''
        pass

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

Create a new  MObject , attach it to this instance, and
initialize it to be empty.'''
        pass

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

'''
        pass

    def stringArray(self, name): 
        '''stringArray(self, name) -> MStringArray
Returns: Returns:
A copy of the MStringArray held in this
instance

Arguments:
	[in]	name = MString

Return an  MStringArray  containing the
string array currently operated upon by the function set. The
 MStringArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set. If the array did not exist it
will be created.'''
        pass

class MFnAttribute:
    '''Dependency node attribute function set.'''
    def __init__(self):
        pass


    def setConnectable(self, state): 
        '''setConnectable(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should allow dependency graph
connections. This should only get called in the initialize call of
your node creator.'''
        pass

    def isUsedAsColor(self): 
        '''isUsedAsColor(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is used as a
color

Returns true if this attribute is to be presented as a color in
the UI.'''
        pass

    def isCached(self): 
        '''isCached(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is cached
locally

Returns true if this attribute is cached locally in the node's
data block. The default for this is true. Caching a node locally
causes a copy of the attribute value for the node to be cached with
the node. This removes the need to traverse through the graph to
get the value each time it is requested.'''
        pass

    def setReadable(self, state): 
        '''setReadable(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should be readable. If an attribute
is readable, then it can be used as the source in a dependency
graph connection.'''
        pass

    def setInternal(self, state): 
        '''setInternal(self, state)
Arguments:
	[in]	state = bool

The function controls an attribute's data storage. When set to
true, the virtual methods  MPxNode::setInternalValueInContext() 
and  MPxNode::getInternalValueInContext() 
are invoked whenever the attribute value is set or queried,
respectively. By default, attributes are not internal.'''
        pass

    def isRenderSource(self): 
        '''isRenderSource(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is render
source

Returns true if this attribute is a render source. This
attribute is used on rendering nodes to override the rendering
sampler info.'''
        pass

    def setWorldSpace(self, state): 
        '''setWorldSpace(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should be treated as worldspace.
Being worldspace indicates the attribute is dependent on the
worldSpace transformation of this node, and will be marked dirty by
any attribute changes in the hierarchy that affects the worldSpace
transformation. The attribute needs to be an array since during
instancing there are multiple worldSpace paths to the node &
Maya requires one array element per path for worldSpace
attributes.'''
        pass

    def isStorable(self): 
        '''isStorable(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
storable

Returns true if this attribute is to be stored when the node is
saved to a file.'''
        pass

    def setHidden(self, state): 
        '''setHidden(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should be hidden from the UI. This
is useful if the attribute is being used for blind data, or if it
is being used as scratch space for a geometry calculation (should
also be marked non-connectable in that case).'''
        pass

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

'''
        pass

    def isIndeterminant(self): 
        '''isIndeterminant(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
indeterminant

Returns true if this attribute is indeterminant. If an attribute
may or may not be used during an evaluation then it is
indeterminant. This attribute classification is mainly used on
rendering nodes to indicate that some attributes are not always
used.'''
        pass

    def parent(self): 
        '''parent(self) -> MObject
Returns: Returns:
The parent attribute

Get the parent of this attribute, if it has one.'''
        pass

    def setChannelBox(self, state): 
        '''setChannelBox(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should appear in the channel box
when the node is selected. This should only get called in the
initialize call of your node creator. Keyable attributes are always
shown in the channel box so this flag is ignored on keyable
attributes. It is for intended for use on non-keyable attributes
which you want to appear in the channel box.'''
        pass

    def isWritable(self): 
        '''isWritable(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
writable

Returns true if this attribute is writable. If an attribute is
writable, then it can be used as the destination in a dependency
graph connection.'''
        pass

    def isConnectable(self): 
        '''isConnectable(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
connectable

Returns true if this attribute accepts dependency graph
connections. If it does, then the readable and writable methods
will indicate what types of connections are accepted.'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: Returns:
The name of the attribute.

Returns the long name of the attribute. If the attribute has no
long name then its short name is returned.'''
        pass

    def internal(self): 
        '''internal(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute uses internal
data

Returns true if a node has internal member data representing
this attribute.'''
        pass

    def isKeyable(self): 
        '''isKeyable(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
keyable

Returns true if this attribute is keyable. Keyable attributes
will be keyed by AutoKey and the Set Keyframe UI. Non-keyable
attributes prevent the user from setting keys via the obvious UI
provided for keying. Being non-keyable is not a hard block against
adding keys to an attribute.'''
        pass

    def isAffectsWorldSpace(self): 
        '''isAffectsWorldSpace(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute affects
worldspace

Returns true if this attribute affects worldspace.'''
        pass

    def isHidden(self): 
        '''isHidden(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
hidden

Returns true if this attribute is to hidden from the UI. The
attribute will not show up in attribute editors.'''
        pass

    def isArray(self): 
        '''isArray(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute stores an
array of data

Returns true if this attribute supports an array of data.'''
        pass

    def setKeyable(self, state): 
        '''setKeyable(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should accept keyframe data. This
should only get called in the initialize call of your node creator.
Keyable attributes will be keyed by AutoKey and the Set Keyframe
UI. Non-keyable attributes prevent the user from setting keys via
the obvious UI provided for keying. Being non-keyable is not a hard
block against adding keys to an attribute.'''
        pass

    def setAffectsWorldSpace(self, state): 
        '''setAffectsWorldSpace(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should affect worldspace. NOTES:
This property is ignored on non-dag nodes.'''
        pass

    def disconnectBehavior(self): 
        '''disconnectBehavior(self) -> MFnAttribute.DisconnectBehavior
Returns: Returns:
The disconnect behavior

Returns the behavior of this attribute when it is disconnected.
The possible settings are as follows:'''
        pass

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

Sets whether the data for this attribute is cached locally in
the node's data block. The default for this is true. Caching a node
locally causes a copy of the attribute value for the node to be
cached with the node. This removes the need to traverse through the
graph to get the value each time it is requested. This should only
get called in the initialize call of your node creator.'''
        pass

    def setRenderSource(self, state): 
        '''setRenderSource(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should be used as a render source
attribute. When writing shader plug-ins, it is sometimes useful to
be able to modify the sampler info, so upstream shading network can
be re- evaluated with different sampler info values.'''
        pass

    def getAddAttrCmd(self, useLongName): 
        '''getAddAttrCmd(self, useLongName) -> MString
Returns: Returns:
Return status

Arguments:
	[in]	useLongName = bool

Returns a string containing the  addAttr  command which
would be required to recreate the  attribute  on a node. The
command includes the terminating semicolon and is formatted as if
for use with a selected node, meaning that it contains no node
name.'''
        pass

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


true The user must specify the index when connecting to
this attribute using connectAttr
false The next available index can be used when
connecting to this attribute using connectAttr -na

Determines whether the user must specify an index when
connecting to this attribute, or whether the next available index
can be used. This method only applies to array attributes which are
non readable, i.e. destination attributes.'''
        pass

    def isChannelBoxFlagSet(self): 
        '''isChannelBoxFlagSet(self) -> bool
Returns: Returns:
A boolean value indicating the status of the channel box flag
on this attribute

Returns true if this attribute has its channel box flag set.
Attributes will appear in the channel box if their channel box flag
is set or if they are keyable.'''
        pass

    def setParent(self, parent): 
        '''setParent(self, parent)
Arguments:
	[in]	parent = MObject

Sets the parent attribute for this attribute. If the attribute
was already a member of a compound, it will be removed from that
attribute structure, and added to the specified one.'''
        pass

    def shortName(self): 
        '''shortName(self) -> MString
Returns: Returns:
The name of the attribute.

Returns the short name of the attribute. If the attribute has no
short name then its long name is returned.'''
        pass

    def setStorable(self, state): 
        '''setStorable(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should be storable. If an attribute
is storable, then it will be writen out when the node is stored to
a file. This should only get called in the initialize call of your
node creator.'''
        pass

    def setUsesArrayDataBuilder(self, state): 
        '''setUsesArrayDataBuilder(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute uses an array data builder. If true,
then the  MArrayDataBuilder 
class may be used with this attribute to generate its data. If
false,  MArrayDataHandle::builder 
will fail.'''
        pass

    def setDisconnectBehavior(self, behavior): 
        '''setDisconnectBehavior(self, behavior)
Arguments:
	[in]	behavior = MFnAttribute.DisconnectBehavior

Sets the disconnection behavior for this attribute. This
determines what happens when a connection to this attribute is
deleted. This should only get called in the initialize call of your
node creator.'''
        pass

    def setIndeterminant(self, state): 
        '''setIndeterminant(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute is indeterminant. If an attribute
may or may not be used during an evaluation then it is
indeterminant. This attribute classification is mainly used on
rendering nodes to indicate that some attributes are not always
used.'''
        pass

    def kNothing(self):
        '''This is an enum of DisconnectBehavior.
Description: Do nothing to the attribute's value.
Value: 2'''
        pass

    def kReset(self):
        '''This is an enum of DisconnectBehavior.
Description: Reset the attribute to its default.
Value: 1'''
        pass

    def kDelete(self):
        '''This is an enum of DisconnectBehavior.
Description: Delete array element (array attributes only).
Value: 0'''
        pass

    class DisconnectBehavior:
        '''Non-functional class.  Values for this enum:
        kNothing
        kReset
        kDelete
'''
        def __init__(self):
            pass

    def usesArrayDataBuilder(self): 
        '''usesArrayDataBuilder(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute uses an array
data builder.

Returns true if this attribute uses an array data builder. If
so, then the  MArrayDataBuilder 
class may be used with this attribute.'''
        pass

    def isWorldSpace(self): 
        '''isWorldSpace(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
worldspace

Returns true if this attribute is worldspace.'''
        pass

    def accepts(self, id): 
        '''accepts(self, id) -> bool
Returns: Returns:
A boolean value indicating whether a connection of that type is
valid

Arguments:
	[in]	id = MTypeId

Returns true if this attribute can accept a connection of the
given type.'''
        pass

    def setIndexMatters(self, state): 
        '''setIndexMatters(self, state)
Arguments:
	[in]	state = bool

If the attribute is an array, then this method specifies whether
to force the user to specify an index when connecting to this
attribute, or to use the next available index.'''
        pass

    def setUsedAsColor(self, state): 
        '''setUsedAsColor(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should be presented as a color in
the UI.'''
        pass

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

'''
        pass

    def setWritable(self, state): 
        '''setWritable(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should be writable. If an attribute
is writable, then it can be used as the destination in a dependency
graph connection. If an attribute is not writable then
 setAttr  commands will fail to change the attribute.'''
        pass

    def isReadable(self): 
        '''isReadable(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
readable

Returns true if this attribute is readable. If an attribute is
readable, then it can be used as the source in a dependency graph
connection.'''
        pass

    def setArray(self, state): 
        '''setArray(self, state)
Arguments:
	[in]	state = bool

Sets whether this attribute should have an array of data. This
should be set to true if the attribute needs to accept multiple
incoming connections.'''
        pass

    def isDynamic(self): 
        '''isDynamic(self) -> bool
Returns: Returns:
A boolean value indicating whether this attribute is
dynamic

Returns true if this attribute is a dynamic attribute.'''
        pass

class MFnBase:
    '''Function Set Base Class.'''
    def __init__(self):
        pass


    def hasObj(self, object): 
        '''hasObj(self, object) -> bool
Returns: Returns:


true = Compatible
false = Not Compatible

Arguments:
	[in]	object = MObject

Determines whether or not the Function Set is compatible with
the specified Maya Object within the API RTTI system.'''
        pass

    def object(self): 
        '''object(self) -> MObject
Returns: Returns:
An MObject that
references the object to which the Function Set is attached. If the
function set is not attached to an MObject, MObject::kNullObj
will be returned.

Returns the  MObject 
that is attached to the Function Set.'''
        pass

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

Determines the type of the Function Set within the API RTTI
system.'''
        pass

    def setObject(self, object): 
        '''setObject(self, object)
Arguments:
	[in]	object = MObject

Attaches the Function Set to the specified Maya Object.'''
        pass

class MFnBlinnShader:
    '''Manage Blinn shaders.'''
    def __init__(self):
        pass


    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	UIvisible = bool

Creates a new blinn shader dependency graph node and adds it to
the dependency graph. If the UIvisible parameter is true, the new
node will be connected to the shader classification node (which
allows the UI to recognize the node as a shader). If UIvisible is
false, the node will be created in isolation.'''
        pass

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

'''
        pass

    def setSpecularRollOff(self, specular_rolloff): 
        '''setSpecularRollOff(self, specular_rolloff)
Arguments:
	[in]	specular_rolloff = float

Sets the value of the "specularRollOff" attribute of a shader
node.'''
        pass

    def eccentricity(self): 
        '''eccentricity(self) -> float
Returns: Returns:
The value of the "eccentricity" attribute of the shader
node.

Retrieves the value of the "eccentricity" attribute of a blinn
shader node. This attribute determines the size of the highlight
produced by the shader.'''
        pass

    def setEccentricity(self, eccentr): 
        '''setEccentricity(self, eccentr)
Arguments:
	[in]	eccentr = float

Sets the value of the "eccentricity" attribute of a shader
node.'''
        pass

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

'''
        pass

    def specularRollOff(self): 
        '''specularRollOff(self) -> float
Returns: Returns:
The value of the "specularRollOff" attribute of the shader
node.

Retrieves the value of the "specularRollOff" attribute of a
blinn shader node. This attribute controls the increased oblique
angle reflectivity of the shader.'''
        pass

class MFnCamera:
    '''Function set for cameras.'''
    def __init__(self):
        pass


    def kVerticalFilmFit(self):
        '''This is an enum of FilmFit.
Description: The same idea as horizontal fit, only applied vertically. Thus
the digital image will match the film back exactly in height, but
miss in width.
Value: 2'''
        pass

    def kOverscanFilmFit(self):
        '''This is an enum of FilmFit.
Description: Over-scanning the film gate in the camera view allows us to
choreograph action outside of the frustum from within the camera
view without having to resort to a dolly or zoom. This feature is
also essential for animating image planes.
Value: 3'''
        pass

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

    def kHorizontalFilmFit(self):
        '''This is an enum of FilmFit.
Description: The digital image is made to fit the film back exactly in the
horizontal direction. This then gives each pixel a horizontal size
= (film back width) / (horizontal resolution). The pixel height is
then = (pixel width) / (pixel aspect ratio). Now that the pixel has
a size, resolution gives us a complete image. That image will match
the film back exactly in width. It will almost never match in
height, either being too tall or too short. By playing with the
numbers you can get it pretty close though.
Value: 1'''
        pass

    def kFillFilmFit(self):
        '''This is an enum of FilmFit.
Description: The system calculates both horizontal and vertical fits and
then applies the one that makes the digital image larger than the
film back.
Value: 0'''
        pass

    class FilmFit:
        '''Non-functional class.  Values for this enum:
        kVerticalFilmFit
        kOverscanFilmFit
        kInvalid
        kHorizontalFilmFit
        kFillFilmFit
'''
        def __init__(self):
            pass

    def filmFitOffset(self): 
        '''filmFitOffset(self) -> double
Returns: Returns:
The film fit offset as double.

Returns the film fit offset for the camera.'''
        pass

    def horizontalFilmOffset(self): 
        '''horizontalFilmOffset(self) -> double
Returns: Returns:
The horizontal film offset for the camera

Returns the horizontal offset of the film. Unit used is
inches.'''
        pass

    def postScale(self): 
        '''postScale(self) -> double
Returns: Returns:
Post scale value.

Return the post projection matrix's post-scale value.'''
        pass

    def setFarClippingPlane(self, dFar): 
        '''setFarClippingPlane(self, dFar)
Arguments:
	[in]	dFar = double

Set the distances to the Far Clipping Plane.'''
        pass

    def setDisplayGateMask(self, displayGateMask): 
        '''setDisplayGateMask(self, displayGateMask)
Arguments:
	[in]	displayGateMask = bool

Activate shaded display of the film or resolution gate mask when
looking through the camera. Does not activate the film or
resolution gate display.'''
        pass

    def verticalShake(self): 
        '''verticalShake(self) -> double
Returns: Returns:
The vertical film-based camera shake value for the camera

Change the vertical film-based camera shake value. Unit used is
inches. This horizontal/vertical attribute pair acts identically to
the film offset pair, but gives another point of input to that
system. This allows film-based camera shake to be accessed
conveniently and independently without disturbing any other
film-offsetting techniques.'''
        pass

    def isDisplayFilmGate(self): 
        '''isDisplayFilmGate(self) -> bool
Returns: Returns:
Boolean value: true The film gate is displayed,
false otherwise.

Determines if the film gate icons are displayed when looking
through the camera.'''
        pass

    def setCameraScale(self, scale): 
        '''setCameraScale(self, scale)
Arguments:
	[in]	scale = double

Sets the camera scale.'''
        pass

    def setEyePoint(self, eyeLocation, space): 
        '''setEyePoint(self, eyeLocation, space)
Arguments:
	[in]	eyeLocation = MPoint
	[in]	space = MSpace.Space

Positions the eye-point of the camera keeping the center of
interest fixed in space. This method changed the orientation and
translation of the camera's transform attributes as well as the
center-of-interest distance.'''
        pass

    def isDepthOfField(self): 
        '''isDepthOfField(self) -> bool
Returns: Returns:
Boolean value: true Depth of field is on, false
otherwise.

Determines whether the depth of field calculation is performed
for the camera. The depth of field calculation is used to give
varying focus depending on the distance of the objects.'''
        pass

    def setFarFocusDistance(self, farFocusDistance): 
        '''setFarFocusDistance(self, farFocusDistance)
Arguments:
	[in]	farFocusDistance = double

Set the farthest distance within the well-focus region'''
        pass

    def setVerticalShake(self, vOffset): 
        '''setVerticalShake(self, vOffset)
Arguments:
	[in]	vOffset = double

Changes the vertical film-based camera shake value. Unit used is
inches.'''
        pass

    def shakeEnabled(self): 
        '''shakeEnabled(self) -> bool
Returns: Returns:
The horizontal film-based camera shake toggle value for the
camera

Returns the toggle value for the camera shake enabled attribute.
If this attribute is false, the horizontalShake and verticalShake
values are ignored by the camera.'''
        pass

    def shakeOverscan(self): 
        '''shakeOverscan(self) -> double
Returns: Returns:
The film-based camera shake overscan value for the camera

Returns the camera shake overscan value. Unit is a multiplier to
the film aperture. This overscan is used to render a larger area
than would be necessary if the camera were not shaking. This
attribute will affect the output render.'''
        pass

    def preScale(self): 
        '''preScale(self) -> double
Returns: Returns:
Pre scale value.

Return the post projection matrix's pre-scale value.'''
        pass

    def setOrthoWidth(self, orthoWidth): 
        '''setOrthoWidth(self, orthoWidth)
Arguments:
	[in]	orthoWidth = double

Sets a new width for the ortho camera. Bad values are
ignored.'''
        pass

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

Returns the focal length limits for the camera.'''
        pass

    def viewDirection(self, space): 
        '''viewDirection(self, space) -> MVector
Returns: Returns:
The view direction vector for the camera

Arguments:
	[in]	space = MSpace.Space

Returns the view direction for the camera.'''
        pass

    def getViewParameters(self, windowAspect, applyOverscan, applySqueeze, applyPanZoom, apertureX, apertureY, offsetX, offsetY): 
        '''getViewParameters(self, windowAspect, applyOverscan, applySqueeze, applyPanZoom, apertureX, apertureY, offsetX, offsetY)
Arguments:
	[in]	windowAspect = double
	[out]	apertureX = double
	[out]	apertureY = double
	[out]	offsetX = double
	[out]	offsetY = double
	[in]	applyOverscan = bool
	[in]	applySqueeze = bool
	[in]	applyPanZoom = bool

Computes and returns the intermediate viewing frustum parameters
for the camera. The aperture and offset are used by
getViewingFrustrum() and getRenderingFrustrum() to compute the
extent (left, right, top, bottom) of the frustrum in the following
manner:'''
        pass

    def setHorizontalFilmAperture(self, hFilmAperture): 
        '''setHorizontalFilmAperture(self, hFilmAperture)
Arguments:
	[in]	hFilmAperture = double

Change the horizontal size of the camera aperture. Unit used is
inches.'''
        pass

    def shutterAngle(self): 
        '''shutterAngle(self) -> double
Returns: Returns:
The shutter angle for the camera

Return the current shutter angle which is one of the variables
used to compute motion blur. The shutter angle is specified in
radians.'''
        pass

    def isMotionBlur(self): 
        '''isMotionBlur(self) -> bool
Returns: Returns:
Boolean value: true Motion blur is on, false
otherwise.

Determine if motion blur is on/off for the camera.'''
        pass

    def nearClippingPlane(self): 
        '''nearClippingPlane(self) -> double
Returns: Returns:
The near clipping plane value for the camera

Returns the distance to the near clipping plane.'''
        pass

    def copyViewFrom(self, otherCamera): 
        '''copyViewFrom(self, otherCamera)
Arguments:
	[in]	otherCamera = MDagPath

Copy the camera settings related to the perspective from the
given camera view.'''
        pass

    def panZoomEnabled(self): 
        '''panZoomEnabled(self) -> bool
Returns: Returns:
The camera 2D pan/zoom toggle value for the camera

Return the toggle value for the camera 2D pan/zoom enabled
attribute. If this attribute is false, the 2D pan/zoom values are
ignored by the camera.'''
        pass

    def setZoom(self, zoom): 
        '''setZoom(self, zoom)
Arguments:
	[in]	zoom = double

Changes the camera 2D zoom value.'''
        pass

    def setVerticalFilmOffset(self, vOffset): 
        '''setVerticalFilmOffset(self, vOffset)
Arguments:
	[in]	vOffset = double

Change the vertical offset of the film. Unit used is inches.'''
        pass

    def setVerticalLock(self, lockFlag): 
        '''setVerticalLock(self, lockFlag)
Arguments:
	[in]	lockFlag = bool

Sets the vertical lock to on or off for the camera.'''
        pass

    def setLensSqueezeRatio(self, aspectRatio): 
        '''setLensSqueezeRatio(self, aspectRatio)
Arguments:
	[in]	aspectRatio = double

Set the squeeze ratio of the lens. The aspect ratio is expressed
as width/height.'''
        pass

    def setDisplayFilmGate(self, displayFilmGate): 
        '''setDisplayFilmGate(self, displayFilmGate)
Arguments:
	[in]	displayFilmGate = bool

Activate display of the film gate icons when looking through the
camera.'''
        pass

    def setParallelView(self, parallelView): 
        '''setParallelView(self, parallelView)
Arguments:
	[in]	parallelView = bool

obsolete & no script support'''
        pass

    def setFilmTranslateH(self, translate): 
        '''setFilmTranslateH(self, translate)
Arguments:
	[in]	translate = double

Set the horizontal film translate.'''
        pass

    def setFStop(self, fStop): 
        '''setFStop(self, fStop)
Arguments:
	[in]	fStop = double

Sets the f-stop value for the camera.'''
        pass

    def setHorizontalFieldOfView(self, fov): 
        '''setHorizontalFieldOfView(self, fov)
Arguments:
	[in]	fov = double

Sets the horizontal field of view for the camera.'''
        pass

    def horizontalFilmAperture(self): 
        '''horizontalFilmAperture(self) -> double
Returns: Returns:
The horizontal film aperture for the camera

Returns the horizontal film aperture for the camera.'''
        pass

    def overscan(self): 
        '''overscan(self) -> double
Returns: Returns:
The percent of overscan

Returns the percent of overscan for this camera.'''
        pass

    def setFilmRollOrder(self, filmRollOrder): 
        '''setFilmRollOrder(self, filmRollOrder)
Arguments:
	[in]	filmRollOrder = MFnCamera.RollOrder

Assign the order in which the film back rotation is applied with
respect to the pivot point.'''
        pass

    def verticalFilmOffset(self): 
        '''verticalFilmOffset(self) -> double
Returns: Returns:
The vertical film offset for the camera

Change the vertical offset of the film. Unit used is inches.'''
        pass

    def setFilmTranslateV(self, translate): 
        '''setFilmTranslateV(self, translate)
Arguments:
	[in]	translate = double

Set the vertical film translate.'''
        pass

    def getFilmFrustum(self, distance, applyPanZoom, clipPlane): 
        '''getFilmFrustum(self, distance, applyPanZoom, clipPlane)
Arguments:
	[in]	distance = double
	[out]	clipPlane = MPoint4
	[in]	applyPanZoom = bool

No script support.'''
        pass

    def set(self, wsEyeLocation, wsViewDirection, wsUpDirection, horizFieldOfView, aspectRatio): 
        '''set(self, wsEyeLocation, wsViewDirection, wsUpDirection, horizFieldOfView, aspectRatio)
Arguments:
	[in]	wsEyeLocation = MPoint
	[in]	wsViewDirection = MVector
	[in]	wsUpDirection = MVector
	[in]	horizFieldOfView = double
	[in]	aspectRatio = double

Convenience routine to set the camera viewing parameters. The
specified values should be in world space where applicable.'''
        pass

    def renderPanZoom(self): 
        '''renderPanZoom(self) -> bool
Returns: Returns:
The camera render 2D pan/zoom toggle value

Return the toggle value for the camera render 2D pan/zoom
attribute. If this attribute is false, the 2D pan/zoom values will
not affect the output render.'''
        pass

    def tumblePivot(self): 
        '''tumblePivot(self) -> MPoint
Returns: Returns:
The tumble pivot location of the camera

Returns the tumble pivot value for the camera. The pivot value
will be in world space coordinates unless  usePivotAsLocalSpace() 
is true in which case the pivot is a relative offset.'''
        pass

    def setMotionBlur(self, motionBlur): 
        '''setMotionBlur(self, motionBlur)
Arguments:
	[in]	motionBlur = bool

Turns motion blur on/off for the camera.'''
        pass

    def setFilmFit(self, filmFit): 
        '''setFilmFit(self, filmFit)
Arguments:
	[in]	filmFit = MFnCamera.FilmFit

Sets how the digital image is to be fitted to the film back.'''
        pass

    def zoom(self): 
        '''zoom(self) -> double
Returns: Returns:
The camera 2D zoom value

Return the camera 2D zoom value, which is the percent over the
film viewable frustum to display'''
        pass

    def filmTranslateH(self): 
        '''filmTranslateH(self) -> double
Returns: Returns:
The horizontal translation amount.

Returns the horizontal film translate value. This value
corresponds to the normalized viewport.'''
        pass

    def setAspectRatio(self, aspectRatio): 
        '''setAspectRatio(self, aspectRatio)
Arguments:
	[in]	aspectRatio = double

Set the aspect ratio of the View. The aspect ratio is expressed
as width/height. This also modifies the entity's scale
transformation to reflect the new aspect ratio.'''
        pass

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

Set the focus at a certain distance in front of the camera.'''
        pass

    def rightDirection(self, space): 
        '''rightDirection(self, space) -> MVector
Returns: Returns:
The right direction vector for the camera

Arguments:
	[in]	space = MSpace.Space

Returns the right direction vector for the camera.'''
        pass

    def filmRollValue(self): 
        '''filmRollValue(self) -> double
Returns: Returns:
Roll value in radians.

Returns the current roll value in radians.'''
        pass

    def setHorizontalRollPivot(self, horizontalRollPivot): 
        '''setHorizontalRollPivot(self, horizontalRollPivot)
Arguments:
	[in]	horizontalRollPivot = double

Set the horizontal roll pivot for film back roll.'''
        pass

    def setPanZoomEnabled(self, enabled): 
        '''setPanZoomEnabled(self, enabled)
Arguments:
	[in]	enabled = bool

Changes the toggle value for the camera 2D pan/zoom enabled
attribute.'''
        pass

    def setStereoHITEnabled(self, enabled): 
        '''setStereoHITEnabled(self, enabled)
Arguments:
	[in]	enabled = bool

Changes the toggle value for the stereo HIT enabled attribute.
If this attribute is false, the stereoHIT value is ignored by the
camera.'''
        pass

    def isVerticalLock(self): 
        '''isVerticalLock(self) -> bool
Returns: Returns:
Boolean value: true Vertical lock is on, false
otherwise.

Determines if vertical lock is turned on for the camera.'''
        pass

    def setClippingPlanes(self, ClippingPlanes): 
        '''setClippingPlanes(self, ClippingPlanes)
Arguments:
	[in]	ClippingPlanes = bool

Turn on/off manual setting of clip planes.'''
        pass

    def farFocusDistance(self): 
        '''farFocusDistance(self) -> double
Returns: Returns:
The far focus distance for the camera

Returns the linear distance to the far focus plane.'''
        pass

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

Set the Center of Interest, which is defined to be a positive
distance along the View Direction (i.e., "in front" of the
Camera).'''
        pass

    def isClippingPlanes(self): 
        '''isClippingPlanes(self) -> bool
Returns: Returns:
Boolean value: true manual clipping planes are
activated, false otherwise.

Determines whether manual clipping planes are activated.'''
        pass

    def verticalRollPivot(self): 
        '''verticalRollPivot(self) -> double
Returns: Returns:
Vertical roll pivot

Returns the vertical roll pivot's value.'''
        pass

    def setOverscan(self, overscan): 
        '''setOverscan(self, overscan)
Arguments:
	[in]	overscan = double

Set the percent of overscan for this camera.'''
        pass

    def setShakeOverscan(self, overscan): 
        '''setShakeOverscan(self, overscan)
Arguments:
	[in]	overscan = double

Changes the camera shake overscan value. Unit is a multiplier to
the film aperture size. This attribute will affect the output
render.'''
        pass

    def nearFocusDistance(self): 
        '''nearFocusDistance(self) -> double
Returns: Returns:
The near focus distance for the camera

Returns the linear distance to the near focus plane.'''
        pass

    def setNearFarClippingPlanes(self, dNear, dFar): 
        '''setNearFarClippingPlanes(self, dNear, dFar)
Arguments:
	[in]	dNear = double
	[in]	dFar = double

Set the distances to the Near and Far Clipping Planes.'''
        pass

    def isOrtho(self): 
        '''isOrtho(self) -> bool
Returns: Returns:
Boolean value: true The camera is orthographic,
false otherwise.

Determines if the camera is in orthographic mode.'''
        pass

    def filmFit(self): 
        '''filmFit(self) -> MFnCamera.FilmFit
Returns: Returns:
The type of film fit.

Returns how the digital image is being fitted to the film
back.'''
        pass

    def setHorizontalFilmOffset(self, hOffset): 
        '''setHorizontalFilmOffset(self, hOffset)
Arguments:
	[in]	hOffset = double

Change the horizontal offset of the film. Unit used is
inches.'''
        pass

    def getRenderingFrustum(self, windowAspect, left, right, bottom, top): 
        '''getRenderingFrustum(self, windowAspect, left, right, bottom, top)
Arguments:
	[in]	windowAspect = double
	[out]	left = double
	[out]	right = double
	[out]	bottom = double
	[out]	top = double

Computes and returns the rendering frustum for the camera. This
is the frustum that the maya renderer uses.'''
        pass

    def getViewingFrustum(self, windowAspect, applyOverscan, applySqueeze, applyPanZoom, left, right, bottom, top): 
        '''getViewingFrustum(self, windowAspect, applyOverscan, applySqueeze, applyPanZoom, left, right, bottom, top)
Arguments:
	[in]	windowAspect = double
	[out]	left = double
	[out]	right = double
	[out]	bottom = double
	[out]	top = double
	[in]	applyOverscan = bool
	[in]	applySqueeze = bool
	[in]	applyPanZoom = bool

Computes and returns the viewing frustum for the camera.'''
        pass

    def setHorizontalShake(self, hOffset): 
        '''setHorizontalShake(self, hOffset)
Arguments:
	[in]	hOffset = double

Change the horizontal film-based camera shake value. Unit used
is inches.'''
        pass

    def farClippingPlane(self): 
        '''farClippingPlane(self) -> double
Returns: Returns:
The far clipping plane value for the camera

Returns the distance to the far clipping plane.'''
        pass

    def verticalFilmAperture(self): 
        '''verticalFilmAperture(self) -> double
Returns: Returns:
The vertical film aperture for the camera

Returns the vertical film aperture for the camera.'''
        pass

    def aspectRatio(self): 
        '''aspectRatio(self) -> double
Returns: Returns:
The aspect ratio

Returns the aspect ratio for the camera.'''
        pass

    def cameraScale(self): 
        '''cameraScale(self) -> double
Returns: Returns:
The scale value of the camera

Returns the camera scale.'''
        pass

    def eyePoint(self, space): 
        '''eyePoint(self, space) -> MPoint
Returns: Returns:
The eye point location for the camera

Arguments:
	[in]	space = MSpace.Space

Returns the eye point for the camera.'''
        pass

    def filmTranslateV(self): 
        '''filmTranslateV(self) -> double
Returns: Returns:
The vertical film translation.

Returns the vertical film translate value. This value
corresponds to the normalized viewport, [-1,1].'''
        pass

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

Returns the minimum and maximum aspect ratio limits for the
camera.'''
        pass

    def setVerticalFieldOfView(self, fov): 
        '''setVerticalFieldOfView(self, fov)
Arguments:
	[in]	fov = double

Sets the vertical field of view for the camera.'''
        pass

    def usePivotAsLocalSpace(self): 
        '''usePivotAsLocalSpace(self) -> bool
Returns: Returns:
True if using local space tumbling for this camera, or false if
using the current global tumble setting in Maya. See setUsePivotAsLocalSpace()
for more details.

Returns the value of the local axis tumble setting for this
camera.'''
        pass

    def filmRollOrder(self): 
        '''filmRollOrder(self) -> MFnCamera.RollOrder
Returns: Returns:
The roll order

Returns the current roll order'''
        pass

    def orthoWidth(self): 
        '''orthoWidth(self) -> double
Returns: Returns:
The orthographic width

Returns the orthographic projection width.'''
        pass

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

Returns the maximum and minimum film aperture limits for the
camera.'''
        pass

    def setFilmRollValue(self, filmRollValue): 
        '''setFilmRollValue(self, filmRollValue)
Arguments:
	[in]	filmRollValue = double

Set the film roll value for film back.'''
        pass

    def focusDistance(self): 
        '''focusDistance(self) -> double
Returns: Returns:
The focus distance for the camera

Returns the focus distance for the camera. This value sets the
focus at a certain distance in front of the camera.'''
        pass

    def hasSamePerspective(self, otherCamera): 
        '''hasSamePerspective(self, otherCamera) -> bool
Returns: Returns:
Boolean value: true Specified camera has same
perspective as this camera, false otherwise.

Arguments:
	[in]	otherCamera = MDagPath

Returns true if the camera has same perspective settings as the
given camera.'''
        pass

    def setShakeOverscanEnabled(self, enabled): 
        '''setShakeOverscanEnabled(self, enabled)
Arguments:
	[in]	enabled = bool

Changes the toggle value for the camera shake overscan enabled
attribute. If this attribute is false, the shakeOverscan value is
ignored by the camera.'''
        pass

    def horizontalPan(self): 
        '''horizontalPan(self) -> double
Returns: Returns:
The camera 2D horizontal pan value

Return the camera 2D horizontal pan value. Unit is inches.'''
        pass

    def focalLength(self): 
        '''focalLength(self) -> double
Returns: Returns:
The focal length for the camera

Returns the focal length for the camera.'''
        pass

    def setVerticalRollPivot(self, verticalRollPivot): 
        '''setVerticalRollPivot(self, verticalRollPivot)
Arguments:
	[in]	verticalRollPivot = double

Set the vertical roll pivot for film back roll.'''
        pass

    def create(self, parent): 
        '''create(self, parent) -> MObject
Returns: Returns:
The transform parenting the new camera

Arguments:
	[in]	parent = MObject

Creates a perspective camera. A parent can be specified for the
new camera, otherwise a transform is created.'''
        pass

    def setTumblePivot(self, point): 
        '''setTumblePivot(self, point)
Arguments:
	[in]	point = MPoint

The tumble pivot is used for non-local tumble operations. It is
in world space for "tumble pivot" mode and relative space for
"local axis" mode (see setUsePivotAsLocalSpace).'''
        pass

    def setNearClippingPlane(self, dNear): 
        '''setNearClippingPlane(self, dNear)
Arguments:
	[in]	dNear = double

Set the distances to the Near Clipping Plane.'''
        pass

    def postProjectionMatrix(self, context): 
        '''postProjectionMatrix(self, context) -> MFloatMatrix
Returns: Returns:
The film roll matrix.

Arguments:
	[in]	context = MDGContext

Returns the post projection matrix used to compute film roll on
the film back plane.'''
        pass

    def setDepthOfField(self, depthOfField): 
        '''setDepthOfField(self, depthOfField)
Arguments:
	[in]	depthOfField = bool

Specifies whether the depth of field calculation is performed
for the camera. The depth of field calculation is used to give
varying focus depending on the distance of the objects.'''
        pass

    def setFocalLength(self, focalLength): 
        '''setFocalLength(self, focalLength)
Arguments:
	[in]	focalLength = double

Sets the focal length for the camera.'''
        pass

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

'''
        pass

    def verticalPan(self): 
        '''verticalPan(self) -> double
Returns: Returns:
The camera 2D vertical pan value

Return the camera 2D vertical pan value. Unit is inches.'''
        pass

    def fStop(self): 
        '''fStop(self) -> double
Returns: Returns:
The F/Stop value for the camera

Returns the f-stop value for the camera.'''
        pass

    def setShakeEnabled(self, enabled): 
        '''setShakeEnabled(self, enabled)
Arguments:
	[in]	enabled = bool

Changes the toggle value for the camera shake enabled attribute.
If this attribute is false, the horizontalShake and verticalShake
values are ignored by the camera.'''
        pass

    def setPreScale(self, sf): 
        '''setPreScale(self, sf)
Arguments:
	[in]	sf = double

Set the pre scale value.'''
        pass

    def setHorizontalPan(self, hPan): 
        '''setHorizontalPan(self, hPan)
Arguments:
	[in]	hPan = double

Changes the camera 2D horizontal pan value. Unit is inches.'''
        pass

    def stereoHITEnabled(self): 
        '''stereoHITEnabled(self) -> bool
Returns: Returns:
The camera stereo HIT toggle value for the camera

Returns the toggle value for the stereo HIT enabled attribute.
If this attribute is false, the stereoHIT value is ignored by the
camera.'''
        pass

    def setShutterAngle(self, shutterAngle): 
        '''setShutterAngle(self, shutterAngle)
Arguments:
	[in]	shutterAngle = double

Change the current shutter angle which is one of the variables
used to compute motion blur. The shutterAngle is specified in
radians.'''
        pass

    def setUsePivotAsLocalSpace(self, how): 
        '''setUsePivotAsLocalSpace(self, how)
Arguments:
	[in]	how = bool

Local space tumbling specifies that when the camera is tumbled,
the camera will rotate about its local axis, offset by the
tumblePivot. The effect is like that of tilting the camera on a
tripod. This per-camera setting overrides whatever tumble mode is
defined globally in Maya.'''
        pass

    def setVerticalPan(self, vPan): 
        '''setVerticalPan(self, vPan)
Arguments:
	[in]	vPan = double

Changes the camera 2D vertical pan value. Unit is inches.'''
        pass

    def setRenderPanZoom(self, render): 
        '''setRenderPanZoom(self, render)
Arguments:
	[in]	render = bool

Changes the toggle value for the camera render 2D pan/zoom
enabled attribute.'''
        pass

    def lensSqueezeRatio(self): 
        '''lensSqueezeRatio(self) -> double
Returns: Returns:
The lens squeeze ratio for the camera

Returns the lens squeeze ratio for the camera.'''
        pass

    def setFilmFitOffset(self, filmFitOffset): 
        '''setFilmFitOffset(self, filmFitOffset)
Arguments:
	[in]	filmFitOffset = double

Set the film fit offset for the camera.'''
        pass

    def verticalFieldOfView(self): 
        '''verticalFieldOfView(self) -> double
Returns: Returns:
The vertical field of view for the camera

Returns the vertical field of view for the camera.'''
        pass

    def setIsOrtho(self, orthoState, useDist): 
        '''setIsOrtho(self, orthoState, useDist)
Arguments:
	[in]	orthoState = bool
	[in]	useDist = double

Switch the camera in and out of orthographic mode. When the
switch happens, the camera has to calculate a new fov or ortho
width, each of which is based on the other and a set distance. The
caller can specify the distance; otherwise the center of interest
is used.'''
        pass

    def centerOfInterestPoint(self, space): 
        '''centerOfInterestPoint(self, space) -> MPoint
Returns: Returns:
The center of interest location of the camera

Arguments:
	[in]	space = MSpace.Space

Returns the center of interest point for the camera.'''
        pass

    def shakeOverscanEnabled(self): 
        '''shakeOverscanEnabled(self) -> bool
Returns: Returns:
The camera shake overscan toggle value for the camera

Returns the toggle value for the camera shake overscan
attribute. If this attribute is false, the shakeOverscan value is
ignored by the camera.'''
        pass

    def setNearFocusDistance(self, nearFocusDistance): 
        '''setNearFocusDistance(self, nearFocusDistance)
Arguments:
	[in]	nearFocusDistance = double

Set the nearest distance within the well-focus region'''
        pass

    def projectionMatrix(self, context): 
        '''projectionMatrix(self, context) -> MFloatMatrix
Returns: Returns:
The projection matrix

Arguments:
	[in]	context = MDGContext

Returns the orthographic or perspective projection matrix for
the camera. The projection matrix that maya's software renderer
uses is almost identical to the OpenGL projection matrix. The
difference is that maya uses a left hand coordinate system and so
the entries [2][2] and [3][2] are negated.'''
        pass

    def horizontalRollPivot(self): 
        '''horizontalRollPivot(self) -> double
Returns: Returns:
The horizontal roll pivot value.

Returns the current horizontal roll pivot value.'''
        pass

    def computeDepthOfField(self, nearLimit): 
        '''computeDepthOfField(self, nearLimit)
Arguments:
	[in]	nearLimit = double

'''
        pass

    def setPostScale(self, sf): 
        '''setPostScale(self, sf)
Arguments:
	[in]	sf = double

Set the post scale value.'''
        pass

    def horizontalFieldOfView(self): 
        '''horizontalFieldOfView(self) -> double
Returns: Returns:
The horizontal field of view for the camera

Returns the horizontal field of view for the camera.'''
        pass

    def setCenterOfInterestPoint(self, centerOfInterest, space): 
        '''setCenterOfInterestPoint(self, centerOfInterest, space)
Arguments:
	[in]	centerOfInterest = MPoint
	[in]	space = MSpace.Space

Positions the center-of-interest of the camera keeping the
eye-point fixed in space. This method changed the orientation and
translation of the camera's transform attributes as well as the
center-of-interest distance.'''
        pass

    def horizontalShake(self): 
        '''horizontalShake(self) -> double
Returns: Returns:
The horizontal film-based camera shake offset for the
camera

Returns the horizontal offset of the film due to the shake
attribute. Unit used is inches. This horizontal/vertical attribute
pair acts identically to the film offset pair, but gives another
point of input to that system. This allows film-based camera shake
to be accessed conveniently and independently without disturbing
any other film-offsetting techniques.'''
        pass

    def setStereoHIT(self, hit): 
        '''setStereoHIT(self, hit)
Arguments:
	[in]	hit = double

Changes the camera stereo horizontal image translation (stereo
HIT) value. Unit is inches. This has the same effect as the HFO
attribute, but is intended as an input hook for use with stereo
camera rigs.'''
        pass

    def setVerticalFilmAperture(self, vFilmAperture): 
        '''setVerticalFilmAperture(self, vFilmAperture)
Arguments:
	[in]	vFilmAperture = double

Change the vertical size of the camera aperture. Unit used is
inches.'''
        pass

    def getPortFieldOfView(self, width, height, horizontalFOV, verticalFOV): 
        '''getPortFieldOfView(self, width, height, horizontalFOV, verticalFOV)
Arguments:
	[in]	width = int
	[in]	height = int
	[out]	horizontalFOV = double
	[out]	verticalFOV = double

Compute the horizontal and vertical field of view in radians
from the given viewport width and height.'''
        pass

    def centerOfInterest(self): 
        '''centerOfInterest(self) -> double
Returns: Returns:
center of interest distance value

Return the linear distance from the camera's eye point to the
center of interest.'''
        pass

    def upDirection(self, space): 
        '''upDirection(self, space) -> MVector
Returns: Returns:
The up direction vector for this camera

Arguments:
	[in]	space = MSpace.Space

Returns the up direction vector for the camera.'''
        pass

    def stereoHIT(self): 
        '''stereoHIT(self) -> double
Returns: Returns:
The stereo HIT value for this camera

Returns the camera stereo horizontal image translation (stereo
HIT) value. Unit is inches. This has the same effect as the HFO
attribute, but is intended as an input hook for use with stereo
camera rigs.'''
        pass

class MFnCameraSet:
    '''Camera set node function set.'''
    def __init__(self):
        pass


    def isLayerActive(self, index): 
        '''isLayerActive(self, index) -> bool
Returns: Returns:
Whether the layer is being processed

Arguments:
	[in]	index = int

Get whether a particular layer is active.'''
        pass

    def setLayerOrder(self, index, order): 
        '''setLayerOrder(self, index, order)
Arguments:
	[in]	index = int
	[in]	order = int

Set the processing order of a particular layer.'''
        pass

    def appendLayer(self, camera): 
        '''appendLayer(self, camera)
Arguments:
	[in]	camera = MDagPath

Appends a layer to the associated cameraSet node using the given
camera. The whole scene will be used with this layer as no object
set is provided.'''
        pass

    def deleteLayer(self, index): 
        '''deleteLayer(self, index)
Arguments:
	[in]	index = int

Deletes the layer denoted by the given index.'''
        pass

    def setLayerSceneData(self, index, set): 
        '''setLayerSceneData(self, index, set)
Arguments:
	[in]	index = int
	[in]	set = MObject

Set the scene data to be used for a particular layer.'''
        pass

    def insertLayer(self, index, camera): 
        '''insertLayer(self, index, camera)
Arguments:
	[in]	index = int
	[in]	camera = MDagPath

Inserts a layer at the given index to the associated cameraSet
node using the given camera. The index value must be in the range
from 0 to the number of layers currently defined. The whole scene
will be used with this layer as no object set is provided.'''
        pass

    def create(self, name, camList, setList): 
        '''create(self, name, camList, setList) -> MObject
Returns: Returns:
A pointer to the new cameraSet node object.

Arguments:
	[in]	name = MString
	[in]	camList = MDagPathArray
	[in]	setList = MObjectArray

Creates a new cameraSet dependency node and puts it in the
dependency graph. The method takes a list of cameras and object
sets and creates a camera layer for each corresponding camera and
object set.'''
        pass

    def setLayerActive(self, index, isActive): 
        '''setLayerActive(self, index, isActive)
Arguments:
	[in]	index = int
	[in]	isActive = bool

Set a particular layer to be active.'''
        pass

    def getSortedIndices(self, sortedIndices): 
        '''getSortedIndices(self, sortedIndices)
Arguments:
	[out]	sortedIndices = MUintArray

Get a list of the layer indices, sorted by the order
attribute.'''
        pass

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

'''
        pass

    def getLayerOrder(self, index, order): 
        '''getLayerOrder(self, index, order)
Arguments:
	[in]	index = int
	[out]	order = int

Get the processing order of a particular layer.'''
        pass

    def setLayerCamera(self, index, camera): 
        '''setLayerCamera(self, index, camera)
Arguments:
	[in]	index = int
	[in]	camera = MDagPath

Set the camera to be used for a particular layer.'''
        pass

    def getNumLayers(self): 
        '''getNumLayers(self) -> int
Returns: Returns:
The number of layers

Return the number of layers in the cameraSet.'''
        pass

    def getLayerCamera(self, index, camera): 
        '''getLayerCamera(self, index, camera)
Arguments:
	[in]	index = int
	[out]	camera = MDagPath

Get the camera used for a particular layer.'''
        pass

    def getLayerSceneData(self, index, set): 
        '''getLayerSceneData(self, index, set)
Arguments:
	[in]	index = int
	[out]	set = MObject

Get the scene data used for a particular layer. The returned
scene data could be  MObject::kNullObj  if
no scene data has been set. The operation will still be deemed
successful.'''
        pass

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

'''
        pass

    def clear(self): 
        '''clear(self)
Clear all of the camera layers.'''
        pass

class MFnComponent:
    '''Base class for component function sets.'''
    def __init__(self):
        pass


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

Returns the  MFn  type of the component.'''
        pass

    def weight(self, index): 
        '''weight(self, index) -> MWeight
Returns: Returns:
The element weight data.

Arguments:
	[in]	index = int

Return the weight data for a given element within this
component. Note that this method does not return external weight
data (e.g. deformer weights stored in separate attributes).'''
        pass

    def setComplete(self, complete): 
        '''setComplete(self, complete)
Arguments:
	[in]	complete = bool

Sets the complete state of the component.'''
        pass

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

Query this component for the existance of attached weight data.
Weight data will be added to a component as part of soft selection
and/or symmetry. Note that this method does not test for the
existance of external weight information (e.g. deformer weights
stored in separate attributes).'''
        pass

    def isComplete(self): 
        '''isComplete(self) -> bool
Returns: Returns:
True if this component is complete, false otherwise

Returns the complete state of the component.'''
        pass

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

'''
        pass

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

Returns the number of elements that this component contains.'''
        pass

    def isEmpty(self): 
        '''isEmpty(self) -> bool
Returns: Returns:
True if empty, false otherwise

Determines if this component is empty, i.e. there are no index
elements.'''
        pass

    def isEqual(self, component): 
        '''isEqual(self, component) -> bool
Returns: Returns:
True if the components are equal, false otherwise

Arguments:
	[in]	component = MObject

Compares this component with the given component.'''
        pass

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

'''
        pass

class MFnComponentListData:
    '''Component list function set for dependency node data.'''
    def __init__(self):
        pass


    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MObject
Returns: Returns:
The indicated component

Arguments:
	[in]	index = int

Extract the indicated component from the const instance. No
checking is done by this class to ensure that the index is valid -
use the length method to determine the size of the array. If the
instance is not attached to an  MObject , this method will return
 MObject::kNullObj .'''
        pass

    def clear(self): 
        '''clear(self)
Remove all components from the component list'''
        pass

    def add(self, obj): 
        '''add(self, obj)
Arguments:
	[in]	obj = MObject

Add the given component to the component list.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the indicated component from the component list.'''
        pass

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

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of components in the instance

Return the number of components in the instance.'''
        pass

    def has(self, obj): 
        '''has(self, obj) -> bool
Returns: Returns:
true if the component list contains the component, false
otherwise

Arguments:
	[in]	obj = MObject

Determine if the instance of the component list contains the
component represented by the given  MObject .'''
        pass

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

'''
        pass

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

Create a new  MObject , attach it to this instance, and
initialize it to contain an empty component list.'''
        pass

class MFnCompoundAttribute:
    '''Compound attribute function set.'''
    def __init__(self):
        pass


    def addChild(self, child): 
        '''addChild(self, child)
Arguments:
	[in]	child = MObject

Add a child attribute under this compound attribute.'''
        pass

    def getAddAttrCmds(self, useLongNames, cmds): 
        '''getAddAttrCmds(self, useLongNames, cmds)
Arguments:
	[out]	cmds = MStringArray
	[in]	useLongNames = bool

Returns a string array containing the  addAttr  commands
which would be required to recreate the attribute and all of its
descendents on a node.'''
        pass

    def create(self, full, brief): 
        '''create(self, full, brief) -> MObject
Returns: Returns:
Return status

Arguments:
	[in]	full = MString
	[in]	brief = MString

Creates a new compound attribute.'''
        pass

    def numChildren(self): 
        '''numChildren(self) -> int
Returns: Returns:
The number of children

Returns the number of child attributes that this compound
attribute has.'''
        pass

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

'''
        pass

    def removeChild(self, child): 
        '''removeChild(self, child)
Arguments:
	[in]	child = MObject

Remove a child attribute from this compound attribute.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject
Returns: Returns:
The child attribute

Arguments:
	[in]	index = int

Get a child of this compound attribute.'''
        pass

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

'''
        pass

class MFnContainerNode:
    '''container function set'''
    def __init__(self):
        pass


    def getPublishedNodes(self, type, publishedNames, nodes): 
        '''getPublishedNodes(self, type, publishedNames, nodes)
Arguments:
	[in]	type = MFnContainerNode.MPublishNodeType
	[out]	publishedNames = MStringArray
	[out]	nodes = MObjectArray

Return a list of the published nodes of a given type. For any
names that have assigned nodes, return the node at the
corresponding array index. For any names that do not have assigned
nodes, a NULL  MObject 
will be at the corresponding array index.'''
        pass

    def getParentContainer(self, parent): 
        '''getParentContainer(self, parent)
Arguments:
	[out]	parent = MObject

Return the parent container, if there is one. Otherwise return
an empty  MObject'''
        pass

    def kGeneric(self):
        '''This is an enum of MPublishNodeType.
Description: published as node (non-anchor)
Value: 2'''
        pass

    def kChildAnchor(self):
        '''This is an enum of MPublishNodeType.
Description: published as child anchor
Value: 1'''
        pass

    def kParentAnchor(self):
        '''This is an enum of MPublishNodeType.
Description: published as parent anchor
Value: 0'''
        pass

    class MPublishNodeType:
        '''Non-functional class.  Values for this enum:
        kGeneric
        kChildAnchor
        kParentAnchor
'''
        def __init__(self):
            pass

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

'''
        pass

    def getPublishedPlugs(self, publishedPlugs, publishedNames): 
        '''getPublishedPlugs(self, publishedPlugs, publishedNames)
Arguments:
	[out]	publishedPlugs = MPlugArray
	[out]	publishedNames = MStringArray

Return two arrays: the first contains the plugs that have been
published on this container. The second contains that published
names for those plugs. There is a one-to-one correspondence between
the plugs in the first array and the strings in the second.'''
        pass

    def getMembers(self, members): 
        '''getMembers(self, members)
Arguments:
	[out]	members = MObjectArray

Return an array of the nodes included in this container.'''
        pass

    def getRootTransform(self, root): 
        '''getRootTransform(self, root)
Arguments:
	[out]	root = MObject

Return the root transform, if there is one. Otherwise return an
empty  MObject .'''
        pass

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

'''
        pass

    def getSubcontainers(self, subcontainers): 
        '''getSubcontainers(self, subcontainers)
Arguments:
	[out]	subcontainers = MObjectArray

Return an array of the container nodes included in this
container.'''
        pass

    def getPublishedNames(self, unboundOnly, publishedNames): 
        '''getPublishedNames(self, unboundOnly, publishedNames)
Arguments:
	[out]	publishedNames = MStringArray
	[in]	unboundOnly = bool

Return a list of published names on the container. Depending on
the arguments, either all published names or only unbound published
names will be returned.'''
        pass

class MFnDagNode:
    '''DAG Node Function Set.'''
    def __init__(self):
        pass


    def addChild(self, child, index, keepExistingParents): 
        '''addChild(self, child, index, keepExistingParents)
Arguments:
	[in]	child = MObject
	[in]	index = int
	[in]	keepExistingParents = bool

Makes the given DAG Node a child of the DAG Node to which this
instance of the Function Set is attached.'''
        pass

    def setInstanceable(self, how): 
        '''setInstanceable(self, how)
Arguments:
	[in]	how = bool

Sets whether or not the DAG node is instanceable. If the node is
marked as noninstanceable, then if Maya attempts to create
instances on the node the instancing operation will not succeed and
instead an error will be reported. A node cannot be marked
non-instanceable if it or any of its children are currently
instanced.  MS::kFailure  will be returned it
this occurs. The default instanceable state for newly created nodes
if true, meaning that nodes can be instanced by default.'''
        pass

    def fullPathName(self): 
        '''fullPathName(self) -> MString
Returns: Returns:
The full path name

Return a string representing the full path from the root of the
dag to this object.'''
        pass

    def parentCount(self): 
        '''parentCount(self) -> int
Returns: Returns:
Number of parent Nodes.

Determines the number of parent Nodes of the Node. Used to
determine the upper bound for the parent index (max index =
parentCount-1).'''
        pass

    def setObjectColor(self, index): 
        '''setObjectColor(self, index)
Arguments:
	[in]	index = int

Sets the index for the current user defined inactive color used
by the node.'''
        pass

    def dagRoot(self): 
        '''dagRoot(self) -> MObject
Returns: Returns:
The DAG root

Determines the root of the first DAG Path to the DAG Node
attached to the Function Set.'''
        pass

    def hasParent(self, node): 
        '''hasParent(self, node) -> bool
Returns: Returns:
true if the node is a parent, false
otherwise.

Arguments:
	[in]	node = MObject

Determines whether or not the given Node is a parent of the DAG
Node attached to the Function Set.'''
        pass

    def setIntermediateObject(self, isIntermediate): 
        '''setIntermediateObject(self, isIntermediate)
Arguments:
	[in]	isIntermediate = bool

Sets whether this object is an intermediate in a geometry
calculation.'''
        pass

    def setObject(self, object): 
        '''setObject(self, object)
Arguments:
	[in]	object = MObject

No script support.'''
        pass

    def inUnderWorld(self): 
        '''inUnderWorld(self) -> bool
Returns: Returns:
true if the node is an underworld node, false
otherwise.

Determines whether or not the DAG Node is an underworld node.
(An example of an underworld node is a  curve on
surface .)'''
        pass

    def create(self, type, name, parent): 
        '''create(self, type, name, parent) -> MObject
Returns: Returns:
The new dependency node or the transform added above it.

Arguments:
	[in]	type = MString
	[in]	name = MString
	[in]	parent = MObject

Creates a new DAG node with the given type tag. The new node is
placed into the DAG.'''
        pass

    def partialPathName(self): 
        '''partialPathName(self) -> MString
Returns: Returns:
The partial path name

Return a string representing the partial path from the root of
the dag to this object.'''
        pass

    def getPath(self, path): 
        '''getPath(self, path)
Arguments:
	[out]	path = MDagPath

Returns a DAG Path to the DAG Node attached to the Function Set.
The difference between this method and the method  dagPath 
below is that this one will not fail if the function set is not
attached to a dag path, it will always return  a  path to
the node.  dagPath  will fail if the function set is not
attached to a dag path.'''
        pass

    def duplicate(self, instance, leafInstance): 
        '''duplicate(self, instance, leafInstance) -> MObject
Returns: Returns:
A reference to the newly created node.

Arguments:
	[in]	instance = bool
	[in]	leafInstance = bool

This method duplicates the DAG hierarchy rooted at the current
node. The copy will have the same parent, if any, as the original
node.'''
        pass

    def inModel(self): 
        '''inModel(self) -> bool
Returns: Returns:
true if the node in the model, false
otherwise.

Determines whether or not the DAG Node is in the model.'''
        pass

    def removeChildAt(self, index): 
        '''removeChildAt(self, index)
Arguments:
	[in]	index = int

Removes the child at the given index from the parent. Once the
child is removed, all children at higher indices would shift 1
position to the left.'''
        pass

    def isParentOf(self, node): 
        '''isParentOf(self, node) -> bool
Returns: Returns:
true is a parent, false otherwise.

Arguments:
	[in]	node = MObject

Determines whether or not the DAG Node attached to the Function
Set is a parent of the given node.'''
        pass

    def isInstanceable(self): 
        '''isInstanceable(self) -> bool
Returns: Returns:
true if the DAG node is instanceable, false
otherwise.

Returns true if the DAG node can be instanced, and false
otherwise.'''
        pass

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

'''
        pass

    def childCount(self): 
        '''childCount(self) -> int
Returns: Returns:
Number of child Nodes.

Determines the number of child Nodes of the Node. Used to
determine the upper bound for the child index (max index =
childCount-1).'''
        pass

    def isInstancedAttribute(self, attribute): 
        '''isInstancedAttribute(self, attribute) -> bool
Returns: Returns:
A boolean value indicating whether the attribute is
instanced

Arguments:
	[in]	attribute = MObject

Returns true if the specified attribute is instanced. An
instanced attribute is an array attribute whose index depends upon
which instance of the node is being referred to.'''
        pass

    def instanceCount(self, total): 
        '''instanceCount(self, total) -> int
Returns: Returns:
Number of instances (direct or indirect according to indirect
instance flag).

Arguments:
	[in]	total = bool

Determines the number of times the Node attached to the Function
Set is instanced.'''
        pass

    def transformationMatrix(self): 
        '''transformationMatrix(self) -> MMatrix
Returns: Returns:
Object space transformation matrix.

Returns the object space transformation matrix for this DAG
node. In general, only transform nodes have matrices associated
with them. Nodes such as shapes (geometry nodes) do not have
transform matrices.'''
        pass

    def parent(self, i): 
        '''parent(self, i) -> MObject
Returns: Returns:
The parent Node for the given index.

Arguments:
	[in]	i = int

Queries the DAG Node attached to the Function Set for the parent
Node corresponding to the given index.'''
        pass

    def enum(self): 
        '''enum(self) -> anonymous

Anonymous enum to store constant values.'''
        pass

    def usingObjectColor(self): 
        '''usingObjectColor(self) -> bool
Returns: Returns:
True if using the user defined inactive object color

Determines whether or not the user defined inactive color will
be used for the node, or whether the default inactive color will be
used.'''
        pass

    def child(self, i): 
        '''child(self, i) -> MObject
Returns: Returns:
The child Node for the given index.

Arguments:
	[in]	i = int

Queries the DAG Node attached to the Function Set for the child
Node corresponding to the given index.'''
        pass

    def boundingBox(self): 
        '''boundingBox(self) -> MBoundingBox
Returns: Returns:
The bounding box for the dag node

Returns the bounding box for the dag node in object space.'''
        pass

    def hasChild(self, node): 
        '''hasChild(self, node) -> bool
Returns: Returns:
true if the node is a child, false
otherwise.

Arguments:
	[in]	node = MObject

Determines whether or not the given Node is a child of the DAG
Node attached to the Function Set.'''
        pass

    def isChildOf(self, node): 
        '''isChildOf(self, node) -> bool
Returns: Returns:
true is a child, false otherwise.

Arguments:
	[in]	node = MObject

Determines whether or not the DAG Node attached to the Function
Set is a child of the given node.'''
        pass

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

'''
        pass

    def removeChild(self, child): 
        '''removeChild(self, child)
Arguments:
	[in]	child = MObject

Removes the given DAG Node from the parent. Once the child is
removed, all children at higher indices would shift 1 position to
the left.'''
        pass

    def setUseObjectColor(self, useObjectColor): 
        '''setUseObjectColor(self, useObjectColor)
Arguments:
	[in]	useObjectColor = bool

Sets whether or not the user defined inactive object color will
be used.'''
        pass

    def getAllPaths(self, paths): 
        '''getAllPaths(self, paths)
Arguments:
	[out]	paths = MDagPathArray

Determines all DAG Paths to the DAG Node attached to the
Function Set.'''
        pass

    def objectColor(self): 
        '''objectColor(self) -> int
Returns: Returns:
Index for current user defined inactive color (0 - 7)

Determines the index for the current user defined inactive color
used by the node. Valid indices are from 0 to 7.'''
        pass

    def dagPath(self): 
        '''dagPath(self) -> MDagPath
Returns: Returns:
An MDagPath that references the object to which the
Function Set is attached. If the function set is not attached to a
dag path an uninitialized MDagPath will be
returned.

Returns the DagPath to which the Function Set is attached. The
difference between this method and the method  getPath 
above is that this one will fail if the function set is not
attached to a dag path.  getPath  will find a dag path if
the function set is not attached to one.'''
        pass

    def isInstanced(self, indirect): 
        '''isInstanced(self, indirect) -> bool
Returns: Returns:
true if the node is instanced (directly or indirectly
according to indirect instance flag), false otherwise.

Arguments:
	[in]	indirect = bool

Determines whether the DAG Node attached to the Function Set is
directly or indirectly instanced.'''
        pass

    def isIntermediateObject(self): 
        '''isIntermediateObject(self) -> bool
Returns: Returns:
True if this is an intermediate object.

Returns true if this object is an intermediate in a geometry
calculation.'''
        pass

class MFnDependencyNode:
    '''Dependency node function set.'''
    def __init__(self):
        pass


    def typeId(self): 
        '''typeId(self) -> MTypeId
Returns: Returns:
The type id of this node

Returns the type id of this node. The type is is the 4 byte code
that is used in the binary file format to identify the type of this
node.'''
        pass

    def classification(self, nodeTypeName): 
        '''classification(self, nodeTypeName) -> MString
Returns: Returns:
The classification string. If the node does not have an
associated classification, an empty string will be returned.

Arguments:
	[in]	nodeTypeName = MString

Retrieves the  classification string  for a node type.
This is a string that is used in dependency nodes that are also
shaders to provide more detailed  type  information to the
rendering system. See the documentation for the MEL commands
 getClassification  and  listNodeTypes  for
information on the strings that can be provided.'''
        pass

    def removeAttribute(self, attribute, type): 
        '''removeAttribute(self, attribute, type)
Arguments:
	[in]	attribute = MObject
	[in]	type = MFnDependencyNode.MAttrClass

Remove an attribute from a node.'''
        pass

    def deallocateFlag(self, pluginName, flag): 
        '''deallocateFlag(self, pluginName, flag)
Arguments:
	[in]	pluginName = MString
	[in]	flag = int

Deallocates a node  flag  which was previously allocated
by a call to  allocateFlag . The flag subsequently becomes
available for reallocation and use by someone else.'''
        pass

    def attribute(self, attrName): 
        '''attribute(self, attrName) -> MObject
Returns: Returns:
A pointer to the attribute

Arguments:
	[in]	attrName = MString

Finds the attribute of this node that has the given name.'''
        pass

    def dgCallbacks(self, timerType, callbackName, value): 
        '''dgCallbacks(self, timerType, callbackName, value)
Arguments:
	[in]	timerType = MFnDependencyNode.MdgTimerType
	[in]	callbackName = MStringArray
	[in]	value = MDoubleArray

Node callbacks that occur when timing is enabled get logged with
the node and can be queried via this method. See the dgCallbackIds
method for getting a further breakdown of the time for an
individual callback on this node.'''
        pass

    def dgTimerReset(self): 
        '''dgTimerReset(self)
The function resets the dependency graph timers and counters for
this node to zero. Note that this method does not start or stop
timing, it only resets the values to zero. If you want to turn on
timing, use the method  dgTimerOn() .
If you want to turn off timing, use  dgTimerOff() .'''
        pass

    def addAttribute(self, attr, type): 
        '''addAttribute(self, attr, type)
Arguments:
	[in]	attr = MObject
	[in]	type = MFnDependencyNode.MAttrClass

Add a new attibute to this node. Note that this operation will
fail if the given  type  parameter is not  MFnDependencyNode::kLocalDynamicAttr .'''
        pass

    def dgCallbackIds(self, timerType, callbackName, callbackId, value): 
        '''dgCallbackIds(self, timerType, callbackName, callbackId, value)
Arguments:
	[in]	timerType = MFnDependencyNode.MdgTimerType
	[in]	callbackName = MString
	[in]	callbackId = MCallbackIdArray
	[in]	value = MDoubleArray

This method provides a further breakdown of the per-callback
time returned via  dgCallbacks() 
by returning the data on a per-callbackId basis. We define a
"callback" to be an event withing Maya that "callback methods" can
be registered with to be invoked when the given event occurs. The
registered client information is called a "callbackId". There can
be multiple callbackIds registered with a given callback, and a
callbackId can be shared amongst multiple nodes or multiple
callbacks.'''
        pass

    def typeName(self): 
        '''typeName(self) -> MString
Returns: Returns:
The type name of this node

Returns the type name of this node. The string returned is the
name of the node type as it is used in the ascii file format.'''
        pass

    def reorderedAttribute(self, index): 
        '''reorderedAttribute(self, index) -> MObject
Returns: Returns:
A pointer to the attribute

Arguments:
	[in]	index = int

Some nodes, such as the various animCurve nodes, require that
their attributes be set in a specific order for proper operation.
Usually this ordering is only important when the node is being
created during file I/O.'''
        pass

    def isDefaultNode(self): 
        '''isDefaultNode(self) -> bool
Returns: Returns:
true if the node is default, false
otherwise.

Returns true if the node is a default node.'''
        pass

    def isNewAttribute(self, attr): 
        '''isNewAttribute(self, attr) -> bool
Returns: Returns:
true if the attribute was added within the current
scene, false if the attribute is permanent or was added
within a referenced file.

Arguments:
	[in]	attr = MObject

Indicates whether or not the specified attribute was added to
this node within the current scene.'''
        pass

    def userNode(self): 
        '''userNode(self) -> MPxNode
Returns: Returns:
A pointer to the user data (NULL if not a plug-in node)

If the function set's node is a plug-in node, then this method
will extract the  MPxNode  pointer
from it. This method should only be used on node types that are
provided by the plug-in calling this method.'''
        pass

    def create(self, type, name): 
        '''create(self, type, name) -> MObject
Returns: Returns:
A pointer to the new dependency node object

Arguments:
	[in]	type = MString
	[in]	name = MString

Creates a new dependency node with the given type. The new node
is placed into the dependency graph.'''
        pass

    def isFromReferencedFile(self): 
        '''isFromReferencedFile(self) -> bool
Returns: Returns:
true if the node came from a referenced file,
false otherwise.

Indicates whether or not this node came from a referenced file.
If it did, the node will be marked as read-only in the scene and
changes to the node's attributes will be saved in the main scene
file, not the referenced from from which the node came.'''
        pass

    def deallocateAllFlags(self, pluginName): 
        '''deallocateAllFlags(self, pluginName)
Arguments:
	[in]	pluginName = MString

Deallocates all of the node flags which are currently allocated
to the specified plugin. The deallocated flags immediately become
available for use by any plugin.'''
        pass

    def isLocked(self): 
        '''isLocked(self) -> bool
Returns: Returns:
true if the node is locked, false otherwise.

Indicates whether or not this node is locked. See the
 setLocked  method for more information on what it means for a
node to be locked.'''
        pass

    def setFlag(self, flag, state): 
        '''setFlag(self, flag, state)
Arguments:
	[in]	flag = int
	[in]	state = bool

Sets the  state  of the specified  flag  for the
node.'''
        pass

    def kInvalidAttr(self):
        '''This is an enum of MAttrClass.
Description: None of the above.
Value: 3'''
        pass

    def kNormalAttr(self):
        '''This is an enum of MAttrClass.
Description: Static attribute which is part of the original definition for
this node type.
Value: 2'''
        pass

    def kLocalDynamicAttr(self):
        '''This is an enum of MAttrClass.
Description: Dynamically added, applies to this specific node.
Value: 1'''
        pass

    class MAttrClass:
        '''Non-functional class.  Values for this enum:
        kInvalidAttr
        kNormalAttr
        kLocalDynamicAttr
'''
        def __init__(self):
            pass

    def getAffectedByAttributes(self, attr, affectedByAttributes): 
        '''getAffectedByAttributes(self, attr, affectedByAttributes)
Arguments:
	[in]	attr = MObject
	[out]	affectedByAttributes = MObjectArray

Returns an array of attributes that affect the attribute passed
in,  attr . That is, when one of the attributes in
 affectedByAttributes  is marked dirty (changed) then
 attr  will also be marked dirty. For nodes defined in
plug-ins this call returns all those attributes that were marked as
affecting the given one via the  MPxNode::attributeAffects 
call.'''
        pass

    def attributeClass(self, attribute): 
        '''attributeClass(self, attribute) -> MFnDependencyNode.MAttrClass
Returns: Returns:
The class of the attribute. If the node does not have the
specified attribute, then kInvalidAttr is returned as the
class.

Arguments:
	[in]	attribute = MObject

Returns the class (normal, local dynamic, global dynamic) of the
specified attribute.'''
        pass

    def hasUniqueName(self): 
        '''hasUniqueName(self) -> bool
Returns: Returns:
true if the node's name is unique within scene,
false otherwise.

Indicates whether or not this node's name is unique within the
scene.'''
        pass

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

'''
        pass

    def isShared(self): 
        '''isShared(self) -> bool
Returns: Returns:
true if the node is shared, false otherwise.

Indicates whether or not this node is shared. This comes into
play when you attempt to create a new node with the same name as an
existing node. If the existing node is shared, then no new node
will be created. If the existing node is not shared, then the new
node will be created and given a different name.'''
        pass

    def canBeWritten(self): 
        '''canBeWritten(self) -> bool
Returns: Returns:
true if the node can be written, false
otherwise.

Returns true if the node can be written/exported to scene
files.'''
        pass

    def setLocked(self, lock): 
        '''setLocked(self, lock)
Arguments:
	[in]	lock = bool

Locks or unlocks this node.'''
        pass

    def setName(self, name): 
        '''setName(self, name) -> MString
Returns: Returns:
The new name of the node.

Arguments:
	[in]	name = MString

Sets the name of this node.'''
        pass

    def dgTimerQueryState(self): 
        '''dgTimerQueryState(self) -> MFnDependencyNode.MdgTimerState
Returns: Returns:
The node's timer's current on/off state.

The function returns the current on/off state of the node's
timer.'''
        pass

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

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

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

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

    class MdgTimerState:
        '''Non-functional class.  Values for this enum:
        kTimerOff
        kTimerInvalidState
        kTimerUninitialized
        kTimerOn
'''
        def __init__(self):
            pass

    def parentNamespace(self): 
        '''parentNamespace(self) -> MString
Returns: Returns:
The name of the namespace in which this node exists. This will
be a colon separated path. If the object is in the root namespace,
then an empty string will be returned.

Returns the name of the namespace in which this node resides.
Namespaces are often used when importing files to prevent name
collisions.'''
        pass

    def attributeCount(self): 
        '''attributeCount(self) -> int
Returns: Returns:
The attribute count

Returns the number of attributes that this node has.'''
        pass

    def kTimerMetric_computeDuringCallback(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in this node's compute while executing node
callbacks on any node.
Value: 7'''
        pass

    def kTimerMetric_fetch(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent fetching data from plugs.
Value: 4'''
        pass

    def kTimerMetric_callbackNotViaAPI(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in callbacks not registered through the API (i.e
internal Maya callbacks).
Value: 6'''
        pass

    def kTimerMetric_computeNotDuringCallback(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in this nodes compute when not executing any node
callbacks on any nodes.
Value: 8'''
        pass

    def kTimerMetric_callback(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent within node callbacks for this node.
Value: 0'''
        pass

    def kTimerMetric_draw(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent drawing this node.
Value: 3'''
        pass

    def kTimerMetric_callbackViaAPI(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in callbacks which were registered through the
API.
Value: 5'''
        pass

    def kTimerMetric_dirty(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent propogating dirty messages from this node.
Value: 2'''
        pass

    def kTimerMetric_compute(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent within the compute method for this node.
Value: 1'''
        pass

    class MdgTimerMetric:
        '''Non-functional class.  Values for this enum:
        kTimerMetric_computeDuringCallback
        kTimerMetric_fetch
        kTimerMetric_callbackNotViaAPI
        kTimerMetric_computeNotDuringCallback
        kTimerMetric_callback
        kTimerMetric_draw
        kTimerMetric_callbackViaAPI
        kTimerMetric_dirty
        kTimerMetric_compute
'''
        def __init__(self):
            pass

    def hasAttribute(self, attrName): 
        '''hasAttribute(self, attrName) -> bool
Returns: Returns:
true if the node has attribute, false
otherwise.

Arguments:
	[in]	attrName = MString

Returns true if the node already has an attribute with the given
name.'''
        pass

    def getAliasAttr(self, force): 
        '''getAliasAttr(self, force) -> MObject
Returns: Returns:
The MObject
corresponding to the alias attribute.

Arguments:
	[in]	force = bool

The function returns the alias attribute list; returns NULL if
it doesn't exist. If the value of argument 'force' is true, an
alias attribute is created if one doesn't exist.'''
        pass

    def setAlias(self, alias, name, plug, add): 
        '''setAlias(self, alias, name, plug, add) -> bool
Returns: Returns:
True if the alias has been set properly.

Arguments:
	[in]	alias = MString
	[in]	name = MString
	[in]	plug = MPlug
	[in]	add = bool

The function sets the alias attribute.'''
        pass

    def setDoNotWrite(self, flag): 
        '''setDoNotWrite(self, flag)
Arguments:
	[in]	flag = bool

Use this method to mark the "do not write" state of this node.
If set, this node will not be saved when the Maya model is written
out.'''
        pass

    def plugsAlias(self, plug): 
        '''plugsAlias(self, plug) -> MString
Returns: Returns:
Name of the alias attribute.

Arguments:
	[in]	plug = MPlug

The function returns the name of the alias on whose attribute
the given plug is created.'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: Returns:
The name of this node

Returns the name of this node. Note that if the object the
instance of this class is attached to is  data  instead of
being in the graph (ie. the object was created by one of the
MFn*Data function sets, or was passed to an  MPxNode::compute 
function in a data block) then the  name  method will not
work.'''
        pass

    def getAffectedAttributes(self, attr, affectedAttributes): 
        '''getAffectedAttributes(self, attr, affectedAttributes)
Arguments:
	[in]	attr = MObject
	[out]	affectedAttributes = MObjectArray

Returns an array of attributes that are affected by the
attribute passed in. That is, when the given attribute,
 attr  is marked dirty (changed) all the
 affectedAttributes  attributes will also be marked dirty.
For nodes defined in plug-ins this call returns all those
attributes that were marked as being affected by the given one via
the  MPxNode::attributeAffects 
call.'''
        pass

    def findPlug(self, attrName, wantNetworkedPlug): 
        '''findPlug(self, attrName, wantNetworkedPlug) -> MPlug
Returns: Returns:
The plug

Arguments:
	[in]	attrName = MString
	[in]	wantNetworkedPlug = bool

Attempt to find a plug for the given attribute. This method will
first try to find the networked version of the plug if requested.
The networked version of a plug is one that currently exists in the
dependency graph at a particular connection point. If a networked
version is not found, then a standard non-networked plug is
returned.'''
        pass

    def getAliasList(self, strArray): 
        '''getAliasList(self, strArray) -> bool
Returns: Returns:
true if any alias was found, false
otherwise.

Arguments:
	[out]	strArray = MStringArray

The function sets a pointer to the list of all attribute aliases
for this node.'''
        pass

    def dgTimer(self, timerMetric, timerType): 
        '''dgTimer(self, timerMetric, timerType) -> double
Returns: Returns:
Value of the timer in seconds for types of kTimerType_self and
kTimerType_inclusive, and as a simple count for
kTimerType_count.

Arguments:
	[in]	timerMetric = MFnDependencyNode.MdgTimerMetric
	[in]	timerType = MFnDependencyNode.MdgTimerType

The function returns the specified timer value for the current
node. This is the total amount of time spent performing the
requested operation since the timer was last reset (see  dgTimerReset() 
for details). There are numerous timers per node and these are
referenced by the metric and the timer type.'''
        pass

    def findAlias(self, alias, attrObj): 
        '''findAlias(self, alias, attrObj) -> bool
Returns: Returns:
True if the alias was found.

Arguments:
	[in]	alias = MString
	[in]	attrObj = MObject

The function looks for an aliased attribute on this node with
the given name'''
        pass

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

'''
        pass

    def getConnections(self, array): 
        '''getConnections(self, array)
Arguments:
	[out]	array = MPlugArray

Get all of the current connections to this node as an array of
plugs.'''
        pass

    def pluginName(self): 
        '''pluginName(self) -> MString
Returns: Returns:
The name of the plug-in

Returns the name of the plug-in this MFnDependendencyNode was
defined in. The name returned is the name of the plug-in on disk,
and may contain pathname separators (such as `/') and drive letters
(e.g. C:). If this object is not an MFnDependency node, then
 MS::kFailure  is returned
instead.'''
        pass

    def dgTimerOff(self): 
        '''dgTimerOff(self)
The function stops the timing of dependency graph evaluation for
this node'''
        pass

    def dgTimerOn(self): 
        '''dgTimerOn(self)
The function starts the timing for this node. Note that this
does not reset the timers and counters on the node, it merely
activates the timing mechanism within Maya and subsequent timing
values are added to the current timer and counter values. If you
also want the counters to be reset, use the method  dgTimerReset() .'''
        pass

    def isFlagSet(self, flag): 
        '''isFlagSet(self, flag) -> bool
Returns: Returns:
Current state of the flag

Arguments:
	[in]	flag = int

Retrieves the current state of the specified  flag  for a
node.'''
        pass

    def allocateFlag(self, pluginName): 
        '''allocateFlag(self, pluginName) -> int
Returns: Returns:
The newly-allocated flag.

Arguments:
	[in]	pluginName = MString

Allocates a node flag for sole use by the caller. Note that the
flag is not specific to any one node but is made available to the
caller on all nodes. Furthermore, node flags only persist for the
duration of the current Maya session: they are not saved with the
scene.'''
        pass

    def kTimerType_self(self):
        '''This is an enum of MdgTimerType.
Description: Time spent performing an operation, not including any time
spent by child operations. For example, if we are drawing a node
and that requires a compute, self time will only include the time
spent drawing and not the compute time. Self time measures
wall-clock time as opposed to CPU time and the values are in
seconds.
Value: 0'''
        pass

    def kTimerType_inclusive(self):
        '''This is an enum of MdgTimerType.
Description: Time spent performing an operation including all time spent by
child operations. For example, if we are drawing a node and that
requires a compute, inclusive time is the time for the draw plus
compute. Inclusive time measure wall-clock time as opposed to CPU
time and the values are in seconds.
Value: 1'''
        pass

    def kTimerType_count(self):
        '''This is an enum of MdgTimerType.
Description: The number of operations that occurred. Ideally we should
return an integer when this timer type is queried, but there are
two advantages to using a double. 1) it keeps the interface
consistent and 2) integer has a fixed upper bound of roughly four
billion so using a double allows us to exceed this.
Value: 2'''
        pass

    class MdgTimerType:
        '''Non-functional class.  Values for this enum:
        kTimerType_self
        kTimerType_inclusive
        kTimerType_count
'''
        def __init__(self):
            pass

class MFnDirectionalLight:
    '''Manage Directional Light dependency nodes.'''
    def __init__(self):
        pass


    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool

Creates a new directional light dependency graph node and adds
it to the dependency graph. If the UIvisible parameter is true, the
new node will be connected to the light classification node (which
allows the UI to recognize the node as a light) and added to the
default light list. If UIvisible is false, the node will be created
in isolation.'''
        pass

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

'''
        pass

    def setUseLightPosition(self, use_light_position): 
        '''setUseLightPosition(self, use_light_position)
Arguments:
	[in]	use_light_position = bool

Sets the value of the "useLightPosition" attribute of a
directional light.'''
        pass

    def useLightPosition(self): 
        '''useLightPosition(self) -> bool
Returns: Returns:
The value of the "useLightPosition" attribute of the
directional light.

Retrieves the value of the "useLightPosition" attribute of a
directional light. This attribute determines if the objects behind
the light will cast shadows.'''
        pass

    def setShadowAngle(self, shadow_angle): 
        '''setShadowAngle(self, shadow_angle)
Arguments:
	[in]	shadow_angle = float

Sets the value of the "shadowAngle" attribute of a directional
light node.'''
        pass

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

'''
        pass

    def shadowAngle(self): 
        '''shadowAngle(self) -> float
Returns: Returns:
The value of the "shadowAngle" attribute of the light
node.

Retrieves the value of the "shadowAngle" attribute of a
directional light node. This attribute represents an angular
divergence from the direction vector of the light used to calculate
soft shadows.'''
        pass

class MFnDoubleArrayData:
    '''double array function set for dependency node data.'''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MDoubleArray

Set the instance to contain the doubles defined in the given
 MDoubleArray .'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> double
Returns: Returns:
The indicated double

Arguments:
	[in]	index = int

Extract the indicated double from the const instance. No
checking is done by this class to ensure that the index is valid -
use the length method to determine the size of the array. If the
instance is not attached to an  MObject , this method will return an
double containing zero.'''
        pass

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

Arguments:
	[in]	arr = MDoubleArray

Create a new  MObject , attach it to this instance, and
initialize it to contain the data from the given  MDoubleArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MDoubleArray

Copy all the doubles in the instance into the given  MDoubleArray .'''
        pass

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

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of doubles in the instance

Return the number of doubles in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MDoubleArray
Returns: Returns:
A copy of the MDoubleArray held in this
instance

Return an  MDoubleArray  containing the
double array currently operated upon by the function set. The
 MDoubleArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set.'''
        pass

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

'''
        pass

class MFnDoubleIndexedComponent:
    '''Double indexed component function set.'''
    def __init__(self):
        pass


    def getCompleteData(self, maxU, maxV): 
        '''getCompleteData(self, maxU, maxV)
Arguments:
	[out]	maxU = int
	[out]	maxV = int

Returns the number of elements for the complete component. A
complete component means that all elements are selected.'''
        pass

    def getElement(self, index, uIndex, vIndex): 
        '''getElement(self, index, uIndex, vIndex)
Arguments:
	[in]	index = int
	[out]	uIndex = int
	[out]	vIndex = int

Get the specified element from the component.'''
        pass

    def getElements(self, uIndices, vIndices): 
        '''getElements(self, uIndices, vIndices)
Arguments:
	[out]	uIndices = MIntArray
	[out]	vIndices = MIntArray

Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: Returns:
The new component

Arguments:
	[in]	compType = MFn.Type

Create a double indexed component of the given type. Allowable
types are'''
        pass

    def addElements(self, uIndices, vIndices): 
        '''addElements(self, uIndices, vIndices)
Arguments:
	[in]	uIndices = MIntArray
	[in]	vIndices = MIntArray

Add the specified elements to the component.'''
        pass

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

'''
        pass

    def setCompleteData(self, maxU, maxV): 
        '''setCompleteData(self, maxU, maxV)
Arguments:
	[in]	maxU = int
	[in]	maxV = int

Marks the component as complete (meaning all items are selected)
and uses the argument to identify the total number of elements
selected. If the component should contain N element indices, then
the range would be [0,N-1].'''
        pass

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

'''
        pass

    def addElement(self, uIndex, vIndex): 
        '''addElement(self, uIndex, vIndex)
Arguments:
	[in]	uIndex = int
	[in]	vIndex = int

Add the specified element to the component.'''
        pass

class MFnEnumAttribute:
    '''Enumerated attribute function set.'''
    def __init__(self):
        pass


    def setDefault(self, fieldString): 
        '''setDefault(self, fieldString)
Arguments:
	[in]	fieldString = MString

Set a new default value for this enum attribute.'''
        pass

    def addField(self, fieldString, index): 
        '''addField(self, fieldString, index)
Arguments:
	[in]	fieldString = MString
	[in]	index = short

Add a field (a string/index pair) to the enumeration'''
        pass

    def create(self, fullName, briefName, defaultValue): 
        '''create(self, fullName, briefName, defaultValue) -> MObject
Returns: Returns:
The newly created enumerated attribute object.

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString
	[in]	defaultValue = short

Creates an enumerated attribute object.'''
        pass

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

'''
        pass

    def getDefault(self, index): 
        '''getDefault(self, index)
Arguments:
	[out]	index = short

Get the default value for the enum attribute.'''
        pass

    def fieldIndex(self, fieldString): 
        '''fieldIndex(self, fieldString) -> short
Returns: Returns:
The index associated with the given descriptive string.

Arguments:
	[in]	fieldString = MString

Retrieve the index associated with a given string.'''
        pass

    def fieldName(self, index): 
        '''fieldName(self, index) -> MString
Returns: Returns:
The descriptive string corresponding to the given index

Arguments:
	[in]	index = short

Retrieve the string associated with a given index'''
        pass

    def getMin(self, minValue): 
        '''getMin(self, minValue)
Arguments:
	[out]	minValue = short

Return the minimum value for this attribute.'''
        pass

    def getMax(self, maxValue): 
        '''getMax(self, maxValue)
Arguments:
	[out]	maxValue = short

Return the maximum value for this attribute.'''
        pass

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

'''
        pass

    def defaultValue(self): 
        '''defaultValue(self) -> MString
Returns: Returns:
the string value for the default enum

Get the default value for the enum attribute.'''
        pass

class MFnExpression:
    '''Expression function set.'''
    def __init__(self):
        pass


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


true expression will be evaluated whenever time
changes
false

If this is  true , then the expression will be evaluated
whenever time changes, regardless of whether the other inputs have
changed.'''
        pass

    def setUnitConversion(self, conversion): 
        '''setUnitConversion(self, conversion)
Arguments:
	[in]	conversion = MFnExpression.UnitConversion

Set the unit conversion options for the expression node.'''
        pass

    def kNone(self):
        '''This is an enum of UnitConversion.
Description: Do not do any unit conversion.
Value: 1'''
        pass

    def kAngularOnly(self):
        '''This is an enum of UnitConversion.
Description: Only convert angular units.
Value: 2'''
        pass

    def kAll(self):
        '''This is an enum of UnitConversion.
Description: Convert all units.
Value: 0'''
        pass

    class UnitConversion:
        '''Non-functional class.  Values for this enum:
        kNone
        kAngularOnly
        kAll
'''
        def __init__(self):
            pass

    def expression(self): 
        '''expression(self) -> MString
Returns: Returns:
The expression string

Gets the expression string for this expression node.'''
        pass

    def create(self, expression, object): 
        '''create(self, expression, object) -> MObject
Returns: Returns:
The expression node

Arguments:
	[in]	expression = MString
	[in]	object = MObject

This method creates and returns a dependency node for a given
expression.'''
        pass

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

'''
        pass

    def setDefaultObject(self, object): 
        '''setDefaultObject(self, object)
Arguments:
	[in]	object = MObject

Sets the "default" object for the expression. This allows the
expression writer to not type the object name for frequently-used
objects.'''
        pass

    def evaluate(self, result): 
        '''evaluate(self, result)
Arguments:
	[out]	result = MDoubleArray

Evaluate this expression and return the result.'''
        pass

    def setAnimated(self, value): 
        '''setAnimated(self, value)
Arguments:
	[in]	value = bool

Sets the way in which the expression is evaluated.'''
        pass

    def unitConversion(self): 
        '''unitConversion(self) -> MFnExpression.UnitConversion
Returns: Returns:
The unit conversion state for this node

Get the unit conversion status for the expression node.'''
        pass

    def getDefaultObject(self, object): 
        '''getDefaultObject(self, object)
Arguments:
	[out]	object = MObject

Gets the "default" object for the expression. Not all
expressions have a default object. If there is no default object
for the expression, the object will be set to MObject::kNullObject
and the return status will indicate success. This is a completely
legal case that the calling code should check for before blindly
using the returned object.'''
        pass

    def setExpression(self, expression): 
        '''setExpression(self, expression)
Arguments:
	[in]	expression = MString

Sets the expression string for this expression node.'''
        pass

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

'''
        pass

class MFnGenericAttribute:
    '''Generic attribute function set.'''
    def __init__(self):
        pass


    def removeNumericDataAccept(self, oldType): 
        '''removeNumericDataAccept(self, oldType)
Arguments:
	[in]	oldType = MFnNumericData.Type

Remove one of the types that this attribute can accept.'''
        pass

    def removeAccept(self, id): 
        '''removeAccept(self, id)
Arguments:
	[in]	id = MTypeId

Remove one of the types that this attribute can accept. This
method takes the type id (iff tag) of the data objects that can no
longer be accepted.'''
        pass

    def create(self, full, brief): 
        '''create(self, full, brief) -> MObject
Returns: Returns:
New attribute.

Arguments:
	[in]	full = MString
	[in]	brief = MString

Creates a new generic attribute.'''
        pass

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

'''
        pass

    def removeDataAccept(self, oldType): 
        '''removeDataAccept(self, oldType)
Arguments:
	[in]	oldType = MFnData.Type

Remove one of the types that this attribute can accept.'''
        pass

    def addAccept(self, id): 
        '''addAccept(self, id)
Arguments:
	[in]	id = MTypeId

Add a new connection type that this attribute can accept. This
method takes the type id (iff tag) of the data objects that can be
accepted.'''
        pass

    def addDataAccept(self, newType): 
        '''addDataAccept(self, newType)
Arguments:
	[in]	newType = MFnData.Type

Add a new connection type that this attribute can accept.'''
        pass

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

'''
        pass

    def addNumericDataAccept(self, newType): 
        '''addNumericDataAccept(self, newType)
Arguments:
	[in]	newType = MFnNumericData.Type

Add a new connection type that this attribute can accept.'''
        pass

class MFnGeometryData:
    '''Geometry data function set.'''
    def __init__(self):
        pass


    def objectGroup(self, index): 
        '''objectGroup(self, index) -> int
Returns: Returns:
The id of the i'th object group

Arguments:
	[out]	index = int

This method returns the id of the i'th object group contained by
the object.'''
        pass

    def removeObjectGroup(self, id): 
        '''removeObjectGroup(self, id)
Arguments:
	[in]	id = int

This method removes an object group with the given id from the
object.'''
        pass

    def objectGroupType(self, id): 
        '''objectGroupType(self, id) -> MFn.Type
Returns: Returns:
The type of the specified object group component

Arguments:
	[in]	id = int

This method returns the type of the component that the object
group with the given id contains.'''
        pass

    def matrixIsNotIdentity(self): 
        '''matrixIsNotIdentity(self) -> bool
Returns: Returns:
True if the matrix for the geometry is NOT the identity, false
otherwise

Return true if the matrix is different from identity.'''
        pass

    def setMatrix(self, matrix): 
        '''setMatrix(self, matrix)
Arguments:
	[in]	matrix = MMatrix

Reset the matrix the the specified matrix and set the identity
flag if the new matrix is the identity.'''
        pass

    def addObjectGroup(self, id): 
        '''addObjectGroup(self, id)
Arguments:
	[in]	id = int

This method adds an object group to the object with the given
id.'''
        pass

    def hasObjectGroup(self, id): 
        '''hasObjectGroup(self, id) -> bool
Returns: Returns:
True is there is an object group with the given id, false
otherwise

Arguments:
	[in]	id = int

This method returns true if an object group with the given id is
contained in the data.'''
        pass

    def removeObjectGroupComponent(self, id, component): 
        '''removeObjectGroupComponent(self, id, component)
Arguments:
	[in]	id = int
	[in]	component = MObject

This method removes the members of the given Tcomponent to the
object group with the given id.'''
        pass

    def objectGroupCount(self): 
        '''objectGroupCount(self) -> int
Returns: Returns:
The number of object groups

This method returns the number of object groups contained by the
object.'''
        pass

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

'''
        pass

    def addObjectGroupComponent(self, id, component): 
        '''addObjectGroupComponent(self, id, component)
Arguments:
	[in]	id = int
	[in]	component = MObject

This method adds the members of the given component to the
object group with the given id.'''
        pass

    def copyObjectGroups(self, inGeom): 
        '''copyObjectGroups(self, inGeom)
Arguments:
	[in]	inGeom = MObject

Copies the object groups from the given geometry data
object.'''
        pass

    def setObjectGroupComponent(self, id, component): 
        '''setObjectGroupComponent(self, id, component)
Arguments:
	[in]	id = int
	[in]	component = MObject

This method sets the members of the object group with the given
id to be only those in the given component.'''
        pass

    def changeObjectGroupId(self, sourceId, destId): 
        '''changeObjectGroupId(self, sourceId, destId)
Arguments:
	[in]	sourceId = int
	[in]	destId = int

This method changes the id of the object group with the given id
to the new id.'''
        pass

    def objectGroupComponent(self, id): 
        '''objectGroupComponent(self, id) -> MObject
Returns: Returns:
A component containing the members of the specified object
group

Arguments:
	[in]	id = int

This method returns a component which contains the members of
the object group with the given id.'''
        pass

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

'''
        pass

    def matrixIsIdentity(self): 
        '''matrixIsIdentity(self) -> bool
Returns: Returns:
True if the matrix for the geometry is identity, false
otherwise

Return true if the matrix is the identity.'''
        pass

    def getMatrix(self, matrix): 
        '''getMatrix(self, matrix)
Arguments:
	[out]	matrix = MMatrix

Get the matrix associated with the geometry data.'''
        pass

class MFnIntArrayData:
    '''int array function set for dependency node data.'''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MIntArray

Set the instance to contain the integers defined in the given
 MIntArray .'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> int
Returns: Returns:
The indicated integer

Arguments:
	[in]	index = int

Extract the indicated integer from the const instance. No
checking is done by this class to ensure that the index is valid -
use the length method to determine the size of the array. If the
instance is not attached to an  MObject , this method will return an
integer containing zero.'''
        pass

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

Arguments:
	[in]	arr = MIntArray

Create a new  MObject , attach it to this instance, and
initialize it to contain the data from the given  MIntArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MIntArray

Copy all the integers in the instance into the given  MIntArray .'''
        pass

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

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of integers in the instance

Return the number of integers in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MIntArray
Returns: Returns:
A copy of the MIntArray held in this
instance

Return an  MIntArray  containing the integer
array currently operated upon by the function set. The  MIntArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set.'''
        pass

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

'''
        pass

class MFnLambertShader:
    '''Manage Lambert shaders.'''
    def __init__(self):
        pass


    def color(self): 
        '''color(self) -> MColor
Returns: Returns:
The value of the "color" attribute of the shader node.

Retrieves the value of the "color" attribute of a shader node.
This attribute represents the surface color of the shader.'''
        pass

    def glowIntensity(self): 
        '''glowIntensity(self) -> float
Returns: Returns:
The value of the "glowIntensity" attribute of the shader
node.

Retrieves the value of the "glowIntensity" attribute of a shader
node. This attribute represents the constant multplier applied to
the glow color of the shader.'''
        pass

    def refractiveIndex(self): 
        '''refractiveIndex(self) -> float
Returns: Returns:
The value of the "refractiveIndex" attribute of the shader
node.

Retrieves the value of the "refractiveIndex" attribute of a
lambert shader node. This attribute represents the refractive index
of the shader.'''
        pass

    def setAmbientColor(self, ambient_color): 
        '''setAmbientColor(self, ambient_color)
Arguments:
	[in]	ambient_color = MColor

Sets the value of the "ambientColor" attribute of a shader
node.'''
        pass

    def diffuseCoeff(self): 
        '''diffuseCoeff(self) -> float
Returns: Returns:
The value of the "diffuseCoeff" attribute of the shader
node.

Retrieves the value of the "diffuseCoeff" attribute of a lambert
shader node. This attribute represents the diffuse reflectivity of
the shader.'''
        pass

    def setHideSource(self, hide_source): 
        '''setHideSource(self, hide_source)
Arguments:
	[in]	hide_source = bool

Sets the value of the "hideSource" attribute of a shader
node.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	UIvisible = bool

Creates a new lambert shader dependency graph node and adds it
to the dependency graph. If the UIvisible parameter is true, the
new node will be connected to the shader classification node (which
allows the UI to recognize the node as a shader). If UIvisible is
false, the node will be created in isolation.'''
        pass

    def setRefractiveIndex(self, refractive_index): 
        '''setRefractiveIndex(self, refractive_index)
Arguments:
	[in]	refractive_index = float

Sets the value of the "refractiveIndex" attribute of a shader
node.'''
        pass

    def refractedRayDepthLimit(self): 
        '''refractedRayDepthLimit(self) -> short
Returns: Returns:
The value of the "refractedRayDepthLimit" attribute of the
node.

Retrieves the value of the "refractedRayDepthLimit" attribute of
a lambert shader node. This attribute represents the maximum
refracted ray depth used in the shading calculation.'''
        pass

    def setGlowIntensity(self, glow_intensity): 
        '''setGlowIntensity(self, glow_intensity)
Arguments:
	[in]	glow_intensity = float

Sets the value of the "glowIntensity" attribute of a shader
node.'''
        pass

    def setDiffuseCoeff(self, diffuse_coeff): 
        '''setDiffuseCoeff(self, diffuse_coeff)
Arguments:
	[in]	diffuse_coeff = float

Sets the value of the "diffuseCoeff" attribute of a shader
node.'''
        pass

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

'''
        pass

    def setIncandescence(self, incand): 
        '''setIncandescence(self, incand)
Arguments:
	[in]	incand = MColor

Sets the value of the "incandescence" attribute of a shader
node.'''
        pass

    def incandescence(self): 
        '''incandescence(self) -> MColor
Returns: Returns:
The value of the "incandescence" attribute of the shader
node.

Retrieves the value of the "incandescence" attribute of a shader
node. This attribute represents the incandescence of the
shader.'''
        pass

    def setTransparency(self, transp): 
        '''setTransparency(self, transp)
Arguments:
	[in]	transp = MColor

Sets the value of the "transparency" attribute of a shader
node.'''
        pass

    def setRtRefractedColor(self, rt_refracted_color): 
        '''setRtRefractedColor(self, rt_refracted_color)
Arguments:
	[in]	rt_refracted_color = bool

Sets the value of the "rtRefractedColor" attribute of a shader
node.'''
        pass

    def translucenceCoeff(self): 
        '''translucenceCoeff(self) -> float
Returns: Returns:
The value of the "translucenceCoeff" attribute of the shader
node.

Retrieves the value of the "translucenceCoeff" attribute of a
lambert shader node. This attribute represents a constant
multiplier applied to the transparency attribute of the shader.'''
        pass

    def setRefractedRayDepthLimit(self, refracted_ray_depth_limit): 
        '''setRefractedRayDepthLimit(self, refracted_ray_depth_limit)
Arguments:
	[in]	refracted_ray_depth_limit = short

Sets the value of the "refractedRayDepthLimit" attribute of a
lambert shader node.'''
        pass

    def setColor(self, col): 
        '''setColor(self, col)
Arguments:
	[in]	col = MColor

Sets the value of the "color" attribute of a shader node.'''
        pass

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

'''
        pass

    def ambientColor(self): 
        '''ambientColor(self) -> MColor
Returns: Returns:
The value of the "ambientColor" attribute of the shader
node.

Retrieves the value of the "ambientColor" attribute of a shader
node. This attribute represents the ambient color of the
shader.'''
        pass

    def transparency(self): 
        '''transparency(self) -> MColor
Returns: Returns:
The value of the "transparency" attribute of the shader
node.

Retrieves the value of the "transparency" attribute of a shader
node. This attribute represents the surface transparency of the
shader.'''
        pass

    def rtRefractedColor(self): 
        '''rtRefractedColor(self) -> bool
Returns: Returns:
The value of the "rtRefractedColor" attribute of the shader
node.

Retrieves the value of the "rtRefractedColor" attribute of a
shader node. This attribute determines whether the shader uses the
value of the "refractedColor" attribute for the refracted color or
calculated the refracted color itself.'''
        pass

    def hideSource(self): 
        '''hideSource(self) -> bool
Returns: Returns:
The value of the "hideSource" attribute of the shader
node.

Retrieves the value of the "hideSource" attribute of a shader
node. This attribute determines whether or not the computed surface
color is used in the shading computation. If hideSource is true,
then only the computed shader glow color will be used. Otherwise,
both the glow and surface colors will be used.'''
        pass

    def setTranslucenceCoeff(self, translucence_coeff): 
        '''setTranslucenceCoeff(self, translucence_coeff)
Arguments:
	[in]	translucence_coeff = float

Sets the value of the "translucenceCoeff" attribute of a shader
node.'''
        pass

class MFnLatticeData:
    '''Lattice Data dependency graph type.'''
    def __init__(self):
        pass


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

'''
        pass

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

Returns the lattice geometry so that it may be modified using
the  MFnLattice  function set.'''
        pass

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

This method create a new lattice data object for use with the
dependency graph. A node's lattice attribute may be set with this
object using  MDataHandle .'''
        pass

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

'''
        pass

class MFnLayeredShader:
    '''Manage Layered shaders.'''
    def __init__(self):
        pass


    def setGlowColor(self, glow_color, lIndex): 
        '''setGlowColor(self, glow_color, lIndex)
Arguments:
	[in]	glow_color = MColor
	[in]	lIndex = int

Sets the value of the "glowColor" attribute of a shader
node.'''
        pass

    def setHardwareShader(self, hardware_shader): 
        '''setHardwareShader(self, hardware_shader)
Arguments:
	[in]	hardware_shader = MColor

Sets the value of the "hardwareShader" attribute of a shader
node.'''
        pass

    def compositingFlag(self): 
        '''compositingFlag(self) -> short
Returns: Returns:
The value of the "compositingFlag" attribute of the shader
node.

Retrieves the value of the "compositingFlag" attribute of a
shader node.'''
        pass

    def color(self, lIndex): 
        '''color(self, lIndex) -> MColor
Returns: Returns:
The value of the "color" attribute of the shader node.

Arguments:
	[in]	lIndex = int

Retrieves the value of the "color" attribute of a shader node.
This attribute represents the surface color of the shader.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	UIvisible = bool

Creates a new layered shader dependency graph node and adds it
to the dependency graph. If the UIvisible parameter is true, the
new node will be connected to the shader classification node (which
allows the UI to recognize the node as a shader). If UIvisible is
false, the node will be created in isolation.'''
        pass

    def glowColor(self, lIndex): 
        '''glowColor(self, lIndex) -> MColor
Returns: Returns:
The value of the "glowColor" attribute of the shader node.

Arguments:
	[in]	lIndex = int

Retrieves the value of the "glowColor" attribute of a shader
node. This attribute represents the ambient color of the
shader.'''
        pass

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

'''
        pass

    def hardwareColor(self): 
        '''hardwareColor(self) -> MColor
Returns: Returns:
The value of the "hardwareColor" attribute of the shader
node.

Retrieves the value of the "hardwareColor" attribute of a shader
node. This attribute represents the color of the material that
appears in shaded mode.'''
        pass

    def setTransparency(self, transp, lIndex): 
        '''setTransparency(self, transp, lIndex)
Arguments:
	[in]	transp = MColor
	[in]	lIndex = int

Sets the value of the "transparency" attribute of a shader
node.'''
        pass

    def transparency(self, lIndex): 
        '''transparency(self, lIndex) -> MColor
Returns: Returns:
The value of the "transparency" attribute of the shader
node.

Arguments:
	[in]	lIndex = int

Retrieves the value of the "transparency" attribute of a shader
node. This attribute represents the surface transparency of the
shader.'''
        pass

    def setCompositingFlag(self, cflag): 
        '''setCompositingFlag(self, cflag)
Arguments:
	[in]	cflag = short

Sets the value of the "compositingFlag" attribute of a shader
node.'''
        pass

    def setHardwareColor(self, hardware_color): 
        '''setHardwareColor(self, hardware_color)
Arguments:
	[in]	hardware_color = MColor

Sets the value of the "hardwareColor" attribute of a shader
node.'''
        pass

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

'''
        pass

    def hardwareShader(self): 
        '''hardwareShader(self) -> MColor
Returns: Returns:
The value of the "hardwareShader" attribute of the shader
node.

Retrieves the value of the "hardwareShader" attribute of a
layered shader node.'''
        pass

    def setColor(self, col, lIndex): 
        '''setColor(self, col, lIndex)
Arguments:
	[in]	col = MColor
	[in]	lIndex = int

Sets the value of the "color" attribute of a shader node.'''
        pass

class MFnLight:
    '''Manage dependency graph nodes representing lights.'''
    def __init__(self):
        pass


    def rayDepthLimit(self): 
        '''rayDepthLimit(self) -> short
Returns: Returns:
The value of the "rayDepthLimit" attribute of the light
node.

Retrieves the value of the "rayDepthLimit" attribute of a light
node. This attribute determines a cutoff point for shadow
calculations related to the light. Rays whose depth is higher than
the value of this attribute will not trigger a shadow calculation
for the light.'''
        pass

    def useRayTraceShadows(self): 
        '''useRayTraceShadows(self) -> bool
Returns: Returns:
The value of the "useRayTraceShadows" attribute of the light
node.

Retrieves the value of the "useRayTraceShadows" attribute of a
light node. This attribute determines whether or not the light
should raytrace it's shadows.'''
        pass

    def color(self): 
        '''color(self) -> MColor
Returns: Returns:
The value of the "color" attribute of the light node.

Retrieves the value of the "color" attribute of a light node.
This attribute represents the color of the light emitted by the
light node.'''
        pass

    def numShadowSamples(self): 
        '''numShadowSamples(self) -> short
Returns: Returns:
The value of the "numShadowSamples" attribute of the light
node.

Retrieves the value of the "numShadowSamples" attribute of a
light node. This attribute represents the number of shadow samples
per point used in occulusion testing.'''
        pass

    def intensity(self): 
        '''intensity(self) -> float
Returns: Returns:
The value of the "intensity" attribute of the light node.

Retrieves the value of the "intensity" attribute of a light
node. This attribute represents a uniform scaling factor applied to
the light color.'''
        pass

    def setUseRayTraceShadows(self, useRayTraceShadows): 
        '''setUseRayTraceShadows(self, useRayTraceShadows)
Arguments:
	[in]	useRayTraceShadows = bool

Sets the value of the "useRayTraceShadows" attribute of a light
node.'''
        pass

    def lightAmbient(self): 
        '''lightAmbient(self) -> bool
Returns: Returns:
The value of the "lightAmbient" attribute of the light
node.

Retrieves the value of the "lightAmbient" attribute of a light
node. This attribute indicates if the light has an ambient
component.'''
        pass

    def opticalFXvisibility(self): 
        '''opticalFXvisibility(self) -> MColor
Returns: Returns:
The value of the "opticalFXvisibility" attribute of the light
node.

Retrieves the value of the "opticalFXvisibility" attribute of a
light node. This attribute represents an occlusion scaling factor
for light glow effects on this light.'''
        pass

    def setOpticalFXvisibility(self, visibility): 
        '''setOpticalFXvisibility(self, visibility)
Arguments:
	[in]	visibility = MColor

Sets the value of the "opticalFXvisibility" attribute of a light
node.'''
        pass

    def shadowColor(self): 
        '''shadowColor(self) -> MColor
Returns: Returns:
The value of the "shadowColor" attribute of the light
node.

Retrieves the value of the "shadowColor" attribute of a light
node. This attribute represents the color of the shadows cast by
the light.'''
        pass

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

'''
        pass

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

Sets the value of the "centerOfIllumination" attribute of a
light node.'''
        pass

    def setNumShadowSamples(self, num_shadow_samples): 
        '''setNumShadowSamples(self, num_shadow_samples)
Arguments:
	[in]	num_shadow_samples = short

Sets the value of the "numShadowSamples" attribute of a light
node.'''
        pass

    def setShadowColor(self, shadow_color): 
        '''setShadowColor(self, shadow_color)
Arguments:
	[in]	shadow_color = MColor

Sets the value of the "shadowColor" attribute of a light
node.'''
        pass

    def lightDirection(self): 
        '''lightDirection(self) -> MFloatVector
Returns: Returns:
The value of the "lightDirection" attribute of the light
node.

Retrieves the value of the "lightDirection" attribute of a light
node. This attribute represents the direction from the light to the
point being shading.'''
        pass

    def setColor(self, col): 
        '''setColor(self, col)
Arguments:
	[in]	col = MColor

Sets the value of the "color" attribute of a light node.'''
        pass

    def lightDiffuse(self): 
        '''lightDiffuse(self) -> bool
Returns: Returns:
The value of the "lightDiffuse" attribute of the light
node.

Retrieves the value of the "lightDiffuse" attribute of a light
node. This attribute indicates if the light has a diffuse
component.'''
        pass

    def centerOfIllumination(self): 
        '''centerOfIllumination(self) -> double
Returns: Returns:
The value of the "centerOfIllumination" attribute of the light
node.

Retrieves the value of the "centerOfIllumination" attribute of a
light node. This attribute represents the distance to the center of
illumination of the light.'''
        pass

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

'''
        pass

    def lightSpecular(self): 
        '''lightSpecular(self) -> bool
Returns: Returns:
The value of the "lightSpecular" attribute of the light
node.

Retrieves the value of the "lightSpecular" attribute of a light
node. This attribute indicates if the light has a specular
component.'''
        pass

    def setIntensity(self, intens): 
        '''setIntensity(self, intens)
Arguments:
	[in]	intens = float

Sets the value of the "intensity" attribute of a light node.'''
        pass

    def setRayDepthLimit(self, ray_depth_limit): 
        '''setRayDepthLimit(self, ray_depth_limit)
Arguments:
	[in]	ray_depth_limit = short

Sets the value of the "rayDepthLimit" attribute of a light
node.'''
        pass

    def lightIntensity(self): 
        '''lightIntensity(self) -> MColor
Returns: Returns:
The value of the "lightIntensity" attribute of the light
node.

Retrieves the value of the "lightIntensity" attribute of a light
node. This attribute represents the intensity of the light
specified as a color.'''
        pass

class MFnLightDataAttribute:
    '''Light data attribute function set.'''
    def __init__(self):
        pass


    def setDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData): 
        '''setDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData)
Arguments:
	[in]	defDirectionX = float
	[in]	defDirectionY = float
	[in]	defDirectionZ = float
	[in]	defIntensityR = float
	[in]	defIntensityG = float
	[in]	defIntensityB = float
	[in]	defAmbient = bool
	[in]	defDiffuse = bool
	[in]	defSpecular = bool
	[in]	defShadowFraction = float
	[in]	defPreShadowIntensity = float
	[in]	defBlindData = void

Sets the default value for the attribute.'''
        pass

    def create(self, fullName, briefName, direction, intensity, ambient, diffuse, specular, shadowFraction, preShadowIntensity, blindData): 
        '''create(self, fullName, briefName, direction, intensity, ambient, diffuse, specular, shadowFraction, preShadowIntensity, blindData) -> MObject
Returns: Returns:
The newly created LightData attribute object.

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString
	[in]	direction = MObject
	[in]	intensity = MObject
	[in]	ambient = MObject
	[in]	diffuse = MObject
	[in]	specular = MObject
	[in]	shadowFraction = MObject
	[in]	preShadowIntensity = MObject
	[in]	blindData = MObject

Creates a LightData attribute object.'''
        pass

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

'''
        pass

    def getDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData): 
        '''getDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData)
Arguments:
	[out]	defDirectionX = float
	[out]	defDirectionY = float
	[out]	defDirectionZ = float
	[out]	defIntensityR = float
	[out]	defIntensityG = float
	[out]	defIntensityB = float
	[out]	defAmbient = bool
	[out]	defDiffuse = bool
	[out]	defSpecular = bool
	[out]	defShadowFraction = float
	[out]	defPreShadowIntensity = float
	[out]	defBlindData = void

Gets the default value for the attribute.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject
Returns: Returns:
A pointer to the desired child attribute

Arguments:
	[in]	index = int

Gets a pointer to one of the child attributes.'''
        pass

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

'''
        pass

class MFnMatrixAttribute:
    '''Matrix attribute function set.'''
    def __init__(self):
        pass


    def setDefault(self, defaultArg): 
        '''setDefault(self, defaultArg)
Arguments:
	[in]	defaultArg = MFloatMatrix

Sets the default value for the attribute. Use this for setting
the defaults of a float matrix attribute.'''
        pass

    def kDouble(self):
        '''This is an enum of Type.
Description: Matrix of double values.
Value: 1'''
        pass

    def kFloat(self):
        '''This is an enum of Type.
Description: Matrix of float values.
Value: 0'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kDouble
        kFloat
'''
        def __init__(self):
            pass

    def create(self, fullName, briefName, matrixType): 
        '''create(self, fullName, briefName, matrixType) -> MObject
Returns: Returns:
The newly created Matrix attribute object.

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString
	[in]	matrixType = MFnMatrixAttribute.Type

Creates a matrix attribute object.'''
        pass

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

'''
        pass

    def getDefault(self, defaultArg): 
        '''getDefault(self, defaultArg)
Arguments:
	[out]	defaultArg = MFloatMatrix

Gets the default value for the attribute. Use this for getting
the default value of a float matrix attribute.'''
        pass

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

'''
        pass

class MFnMatrixData:
    '''Matrix function set for dependency node data.'''
    def __init__(self):
        pass


    def set(self, mat): 
        '''set(self, mat)
Arguments:
	[in]	mat = MMatrix

Set this instance to hold a copy of the given matrix.'''
        pass

    def matrix(self): 
        '''matrix(self) -> const MMatrix
Returns: Returns:
A const reference to the MMatrix

Return a constant reference to the matrix held in this
instance.'''
        pass

    def create(self, transformation): 
        '''create(self, transformation) -> MObject
Returns: Returns:
The new MObject

Arguments:
	[in]	transformation = MTransformationMatrix

Create a new  MObject , attach it to this instance and
initialize it to the given transform matrix.'''
        pass

    def isTransformation(self): 
        '''isTransformation(self) -> bool
Returns: Returns:
true if the instance holds a transform matrix, false
otherwise

Determine if the matrix held in this instance is a transform
matrix.'''
        pass

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

'''
        pass

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

'''
        pass

    def transformation(self): 
        '''transformation(self) -> MTransformationMatrix
Returns: Returns:
A copy of the MTransformationMatrix held in this
instance

Return a copy of the transform matrix held in this instance.'''
        pass

class MFnMesh:
    '''Polygonal surface function set. - they range between 0..(numVertices()-1)There are several cases in which the create method will alter the
data passed in:use the appropriate vertices. You can optionally specify
texture (uv) coordinates. UV coordinates are 2-d coordinates used
for mapping textures to the polygons of a mesh. All of the uv
coordinates are stored in one or more named UV sets. The default
mesh uv list stores uv coordinates in an array indexed from 0 tonumUVs()-1.
UV's are referenced on a per-polygon per-vertex basis, so for a
polygon with 4 vertices there would be 4 uv's. The uv values for a
polygon are set by specifying the index of the uv for each vertex
of the polygon. This index is the uv's position in the master uv
array. UV's are optional so polygons do not have to have uv values
associated with them. There may be only 1 or 2 polygons in a mesh
that have uv coordinates set, or all of the polygons may have uv's.
UV's can also be shared so several different polygons may reference
the same uv's. If you are creating a UV for the first time or
changing the order of the UV then you need to set the UV using one
of the setUV methods and then assign new indices using one of the
assignUV methods. It is not necessary to call assignUV if editing
the position of an existing UV.For a cube, the list would contain 24 normals (4 vertices * 6
polygons) since the edges for a cube are hard and the per-vertex
per-polygon normals cannot be shared. For a sphere or torus, which
has smooth edges, the normals can be shared, and thus the normal
list contains the same number of normals as vertices. MFnMesh allows you to create
Blind Data types, and to create and access mesh component level
blind data, but not object level blind data. Object level data may
be assigned through the polyBlindData command or the Blind Data
Editor. However, object level blind data is just an ordinary
compound dynamic attribute directly on the object. The parent
attribute name is BlindDataNNNN where NNNN is the blind data
typeID. e.g. if your typeId is 1001 your object will have a
compound dynamic attr called BlindData1001.'''
    def __init__(self):
        pass


    def setCurrentUVSetName(self, setName, modifier, currentSelection): 
        '''setCurrentUVSetName(self, setName, modifier, currentSelection)
Arguments:
	[in]	setName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList

Set the "current" uv set for this object. The "current" uv set
is the uv set to use when no uv set name is specified for a uv set
operation. If the uv set does not exist then the "current" uv set
will not be changed.'''
        pass

    def getBinaryBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getBinaryBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MStringArray

Get the blind data value for the specified blind data attribute
for all components of the given type. If the type of the attribute
is not correct, this method will fail.'''
        pass

    def onBoundary(self, polygonId): 
        '''onBoundary(self, polygonId) -> bool
Returns: Returns:


true If the specified edge is on the border of the object.
false If the specified edge is not on the boundary of the
object.

Arguments:
	[in]	polygonId = int

A method to determines whether the specified face in the mesh is
a boundary face.'''
        pass

    def getInvisibleFaces(self): 
        '''getInvisibleFaces(self) -> MUintArray
Returns: Returns:
The list of invisible face ids.

This method returns the invisible faces of the mesh.'''
        pass

    def setVertexColors(self, colors, vertexList, modifier, rep): 
        '''setVertexColors(self, colors, vertexList, modifier, rep)
Arguments:
	[in]	colors = MColorArray
	[in]	vertexList = MIntArray
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation

Set color of specified channels for these vertices.'''
        pass

    def copyInPlace(self, source): 
        '''copyInPlace(self, source)
Arguments:
	[in]	source = MObject

This method creates copies the given source mesh onto the
current surface. After the copy this function set continues operate
on the original mesh.'''
        pass

    def isColorClamped(self, colorSet): 
        '''isColorClamped(self, colorSet) -> bool
Returns: Returns:


true All components in the color set are clamped
false All components in the color set are not
clamped

Arguments:
	[in]	colorSet = MString

This method returns if the color set has its R,G,B,and A
components clamped in the range from 0 to 1.'''
        pass

    def getTangents(self, space, uvSet, tangents): 
        '''getTangents(self, space, uvSet, tangents)
Arguments:
	[out]	tangents = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return the tangent vectors for all face vertices. The tangent is
defined as the surface tangent of the polygon running in the U
direction defined by the uv map.'''
        pass

    def unlockVertexNormals(self, vertexList): 
        '''unlockVertexNormals(self, vertexList)
Arguments:
	[in]	vertexList = MIntArray

Unlock Shared Normals for these vertices'''
        pass

    def getUVSetFamilyNames(self, familyNames): 
        '''getUVSetFamilyNames(self, familyNames)
Arguments:
	[out]	familyNames = MStringArray

Get the names of all of the uv set families on this object. A uv
set family is a set of per-instance sets with the same name with
each individual set applying to one or more instances. A set which
is shared across all instances will be the sole member of its
family.'''
        pass

    def setCreaseVertices(self, vertexIds, creaseData): 
        '''setCreaseVertices(self, vertexIds, creaseData)
Arguments:
	[in]	vertexIds = MUintArray
	[in]	creaseData = MDoubleArray

This method sets the specified vertices of the mesh as crease
vertices.'''
        pass

    def numVertices(self): 
        '''numVertices(self) -> int
Returns: Returns:
The number of vertices of the mesh

Returns the number of vertices in the vertex list for this mesh.
This number will be the same as the length of the vertex array
returned with the getPoints method.'''
        pass

    def setCheckSamePointTwice(self, check): 
        '''setCheckSamePointTwice(self, check)
Arguments:
	[in]	check = bool

This method allows the turning on or off of duplicate point
checking when polygons are created or added using this class.
Checking for duplicates, is the default state.'''
        pass

    def getFaceVertexColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex): 
        '''getFaceVertexColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex)
Arguments:
	[in]	faceIndex = int
	[in]	localVertexIndex = int
	[out]	colorIndex = int
	[in]	colorSet = MString

Get an index into the array returned by getFaceVertexColors. So
that you can index into the array directly, instead of walking it
in face-vertex order.'''
        pass

    def getVertices(self, vertexCount, vertexList): 
        '''getVertices(self, vertexCount, vertexList)
Arguments:
	[out]	vertexCount = MIntArray
	[out]	vertexList = MIntArray

This method retrieves the  object-relative
(mesh-relative/global)  vertex indices for all polygons. The
indices refer to the elements in the array returned by the
'getPoints' method.'''
        pass

    def currentUVSetName(self, instance): 
        '''currentUVSetName(self, instance) -> MString
Returns: Returns:
UV set name.

Arguments:
	[in]	instance = int

Get the name of the "current" uv set. The "current" uv set is
the uv set which is used for uv operations when no uv set is
explicitly specified.'''
        pass

    def getPolygonVertices(self, polygonId, vertexList): 
        '''getPolygonVertices(self, polygonId, vertexList)
Arguments:
	[in]	polygonId = int
	[out]	vertexList = MIntArray

This method retrieves the  object-relative
(mesh-relative/global)  vertex indices for the specified
polygon. The indices refer to the elements in the array returned by
the 'getPoints' method.'''
        pass

    def addPolygon(self, vertexArray, mergeVertices, pointTolerance, parentOrOwner, faceIndex): 
        '''addPolygon(self, vertexArray, mergeVertices, pointTolerance, parentOrOwner, faceIndex) -> MObject
Returns: Returns:
The transform if one is created, otherwise the geometry.

Arguments:
	[in]	vertexArray = MPointArray
	[out]	faceIndex = int
	[in]	mergeVertices = bool
	[in]	pointTolerance = double
	[in]	parentOrOwner = MObject

Adds a new polygon to this polygonal mesh. Return an index of
the created polygon.'''
        pass

    def collapseEdges(self, edgeList): 
        '''collapseEdges(self, edgeList)
Arguments:
	[in]	edgeList = MIntArray

This function collapse edges into vertices. The two vertices
that create each given edge are replaced in turn by one vertex
placed at the average of the two initial vertex.'''
        pass

    def getEdgeVertices(self, edgeId, vertexList): 
        '''getEdgeVertices(self, edgeId, vertexList)
Arguments:
	[in]	edgeId = int
	[out]	vertexList = int2

This method retrieves the  object-relative
(mesh-relative/global)  vertex indices corresponding to the
specified edge. The indices can be used to refer to the elements in
the array returned by the 'getPoints' method.'''
        pass

    def getAssociatedUVSetTextures(self, uvSetName, textures): 
        '''getAssociatedUVSetTextures(self, uvSetName, textures)
Arguments:
	[in]	uvSetName = MString
	[out]	textures = MObjectArray

Get a list of texture nodes which are using a given uv set. If
the texture has a 2d texture placement, the texture, and not the
placement will be returned.'''
        pass

    def copyUVSetWithName(self, fromName, toName, modifier): 
        '''copyUVSetWithName(self, fromName, toName, modifier) -> MString
Returns: Returns:
The name of the new UV set. May be different then the name
passed in if a new name was generated.

Arguments:
	[in]	fromName = MString
	[in]	toName = MString
	[in]	modifier = MDGModifier

Copies a uv set from one to another for this mesh. The source
must exist. The following cases can occur:'''
        pass

    def getFaceVertexBlindDataIndex(self, faceIndex, vertexIndex, blindDataIndex): 
        '''getFaceVertexBlindDataIndex(self, faceIndex, vertexIndex, blindDataIndex)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	blindDataIndex = int

Get the single index to retrieve face-vertex blind data.'''
        pass

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

Retrieves a string that describes the intersection acceleration
structure for this object, if any. The string is formatted similar
to:'''
        pass

    def getConnectedShaders(self, instanceNumber, shaders, indices): 
        '''getConnectedShaders(self, instanceNumber, shaders, indices)
Arguments:
	[in]	instanceNumber = int
	[out]	shaders = MObjectArray
	[out]	indices = MIntArray

Returns all the shaders (sets) connected to the specified
instance of this mesh. As well as an array of polygon/shader
assignments. The indices array will hold for each polygon in the
mesh, an index into the shaders array. If a polygon does not have a
shader assigned to it, the value of the index will be -1.'''
        pass

    def getBlindDataAttrNames(self, blindDataId, longNames, shortNames): 
        '''getBlindDataAttrNames(self, blindDataId, longNames, shortNames)
Arguments:
	[in]	blindDataId = int
	[out]	longNames = MStringArray
	[out]	shortNames = MStringArray

Get the blind data attribute names for the specified blind data
type id.'''
        pass

    def numUVSets(self): 
        '''numUVSets(self) -> int
Returns: Returns:
The number of uv sets for the object

Returns the number of uv sets for an object.'''
        pass

    def getFaceNormalIds(self, faceIndex, normals): 
        '''getFaceNormalIds(self, faceIndex, normals)
Arguments:
	[in]	faceIndex = int
	[out]	normals = MIntArray

Return normal indices for all vertices for a given face. The
normalIds can be used to index into an array returned by  MFnMesh::getNormals() ;'''
        pass

    def getColor(self, colorId, colorSet, defaultUnsetColor, color): 
        '''getColor(self, colorId, colorSet, defaultUnsetColor, color)
Arguments:
	[in]	colorId = int
	[out]	color = MColor
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor

Get the value of the specified texture coordinate from this
mesh's color list. The colorId is the element in the color list
that will be retrieved. If the color is not set, defaultUnsetColor
will be return. If defaultUnsetColor is not set, (0,0,0,1) will be
return.'''
        pass

    def getVertexNormals(self, angleWeighted, space, normals): 
        '''getVertexNormals(self, angleWeighted, space, normals)
Arguments:
	[in]	angleWeighted = bool
	[out]	normals = MFloatVectorArray
	[in]	space = MSpace.Space

Return all vertex normals. The returned normals are per-vertex
normals, so unshared normals at a vertex will be averaged. See the
class description for more information on normals.'''
        pass

    def numColors(self, colorSet): 
        '''numColors(self, colorSet) -> int
Returns: Returns:
The number of colors

Arguments:
	[in]	colorSet = MString

Returns the number of colors (vertex data) for this mesh. The
colors are stored in a list which is referenced by polygons
requiring textures on a per-polygon per-vertex basis. This method
returns the number of elements in this list.'''
        pass

    def getPoint(self, vertexId, space, pos): 
        '''getPoint(self, vertexId, space, pos)
Arguments:
	[in]	vertexId = int
	[out]	pos = MPoint
	[in]	space = MSpace.Space

Get the position of the specified vertex in this mesh's vertex
list.'''
        pass

    def assignColor(self, polygonId, vertexIndex, colorId, colorSet): 
        '''assignColor(self, polygonId, vertexIndex, colorId, colorSet)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[in]	colorId = int
	[in]	colorSet = MString

Maps a color value to a specified vertex of a polygon.'''
        pass

    def binaryBlindDataComponentId(self, compID, compType, blindDataId, attrName): 
        '''binaryBlindDataComponentId(self, compID, compType, blindDataId, attrName) -> MString
Returns: Returns:
The data item.

Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString

Get the blind data value for the specified blind data attribute
of the specified component. If the type of the attribute is not
correct, this method will fail.'''
        pass

    def setNormals(self, normals, space): 
        '''setNormals(self, normals, space)
Arguments:
	[in]	normals = MFloatVectorArray
	[in]	space = MSpace.Space

Set the normal array (user normals)'''
        pass

    def clearBlindData(self, compType, blindDataId): 
        '''clearBlindData(self, compType, blindDataId)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int

Delete the values for a binary blind data type (all its
attributes) from all components of the given type.'''
        pass

    def getStringBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getStringBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MStringArray

Get the blind data value for the specified blind data attribute
for all components of the given type. If the type of the attribute
is not correct, this method will fail.'''
        pass

    def booleanOp(self, op, mesh1, mesh2): 
        '''booleanOp(self, op, mesh1, mesh2)
Arguments:
	[in]	op = MFnMesh.BoolOperation
	[in]	mesh1 = MFnMesh
	[in]	mesh2 = MFnMesh

Computes the boolean between two meshes. The result is stored in
the current  MFnMesh  instance. The current
instance must point to a valid mesh, which can be empty. Such as
mesh can result from using  MFnMeshData::create() 
for example.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)
Signal that this polygonal mesh has changed and needs to redraw
itself.'''
        pass

    def setFloatBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setFloatBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MFloatArray

Set a values for a float blind data on an array of components.
The arrays of values and components must be the same size.'''
        pass

    def getCurrentUVSetName(self, instance, setName): 
        '''getCurrentUVSetName(self, instance, setName)
Arguments:
	[out]	setName = MString
	[in]	instance = int

This method is not available in Python.'''
        pass

    def setPoint(self, vertexId, pos, space): 
        '''setPoint(self, vertexId, pos, space)
Arguments:
	[in]	vertexId = int
	[in]	pos = MPoint
	[in]	space = MSpace.Space

Sets the position of specified vertex in the vertex list for
this mesh.'''
        pass

    def assignColors(self, colorIds, colorSet): 
        '''assignColors(self, colorIds, colorSet)
Arguments:
	[in]	colorIds = MIntArray
	[in]	colorSet = MString

This method maps all colors for the mesh. The setColor/setColors
method is used to create a color table for the mesh. After the
table is created, this method is used to map those values to each
polygon on a per-vertex basis. The setColor/setColors method should
be called before the assignColors method.'''
        pass

    def numColorSets(self): 
        '''numColorSets(self) -> int
Returns: Returns:
The number of color sets for the object

Returns the number of color sets for an object.'''
        pass

    def deleteVertex(self, vertexId, modifier): 
        '''deleteVertex(self, vertexId, modifier)
Arguments:
	[in]	vertexId = int
	[in]	modifier = MDGModifier

Delete this vertex.'''
        pass

    def lockVertexNormals(self, vertexList): 
        '''lockVertexNormals(self, vertexList)
Arguments:
	[in]	vertexList = MIntArray

Lock Shared Normals for these vertices.'''
        pass

    def getFaceVertexTangent(self, faceIndex, vertexIndex, space, uvSet, tangent): 
        '''getFaceVertexTangent(self, faceIndex, vertexIndex, space, uvSet, tangent)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	tangent = MVector
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return the normalized tangent vector at a given face vertex.'''
        pass

    def setFaceVertexColor(self, faceIndex, localVertexIndex, color, modifier, rep): 
        '''setFaceVertexColor(self, faceIndex, localVertexIndex, color, modifier, rep)
Arguments:
	[in]	faceIndex = int
	[in]	localVertexIndex = int
	[in]	color = MColor
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation

Set color of specified channels for this vertex in this
face.'''
        pass

    def hasBlindDataComponentId(self, compID, compType): 
        '''hasBlindDataComponentId(self, compID, compType) -> bool
Returns: Returns:
true: has the specified blind data, false: does not

Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type

Does this component have any kind of blind data'''
        pass

    def setColors(self, colorArray, colorSet, rep): 
        '''setColors(self, colorArray, colorSet, rep)
Arguments:
	[in]	colorArray = MColorArray
	[in]	colorSet = MString
	[in]	rep = MFnMesh.MColorRepresentation

Sets all of the colors of specified channels for this mesh. The
color array must be at least as large as the current color set
size. You can determine the color set size by calling  numColors() 
for the default color set, or numColors(colorSet) for a named color
set.'''
        pass

    def removeFaceColors(self, faceList): 
        '''removeFaceColors(self, faceList)
Arguments:
	[in]	faceList = MIntArray

Remove previously set color these faces. For each face, the
color will be unset for each vertex-face component in the face.'''
        pass

    def isEdgeSmooth(self, edgeId): 
        '''isEdgeSmooth(self, edgeId) -> bool
Returns: Returns:


true The edge is smooth (soft)
false The edge is hard

Arguments:
	[in]	edgeId = int

This method determines if the specified edge is smooth
(soft).'''
        pass

    def getFloatBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getFloatBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MFloatArray

Get the blind data value for the specified blind data attribute
for all components of the given type. If the type of the attribute
is not correct, this method will fail.'''
        pass

    def getColorRepresentation(self, colorSet): 
        '''getColorRepresentation(self, colorSet) -> MFnMesh.MColorRepresentation
Returns: Returns:


kAlpha The color set contains only Alpha component
kRGB The color set contains only RGB components
kRGBA The color set contains RGBA components

Arguments:
	[in]	colorSet = MString

This method returns the color representation (RGB/RGBA/A) of a
color set.'''
        pass

    def closestIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance): 
        '''closestIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance) -> bool

Arguments:
	[in]	raySource = MFloatPoint
	[in]	rayDirection = MFloatVector
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray
	[in]	idsSorted = bool
	[in]	space = MSpace.Space
	[in]	maxParam = float
	[in]	testBothDirections = bool
	[in]	accelParams = MMeshIsectAccelParams
	[in]	hitPoint = MFloatPoint
	[in]	hitRayParam = float
	[in]	hitFace = int
	[in]	hitTriangle = int
	[in]	hitBary1 = float
	[in]	hitBary2 = float
	[in]	tolerance = float

Finds the closest intersection of a ray starting at raySource
and travelling in rayDirection with the mesh. If faceIds is
non-NULL and triIds is NULL, then only the faces specified by
faceIds will be considered for intersection. If both faceIds and
triIds are non-NULL, then each pair of entries will be taken as a
(face,triangle) pair to be considered for intersection, where
triangles are numbered on each face starting from 0. Thus, the
face-triangle pair (10,0) means the first triangle on face 10. If
both faceIds and triIds are NULL, then all face-triangles in the
mesh will be considered.'''
        pass

    def setSomeColors(self, colorIds, colorArray, colorSet, rep): 
        '''setSomeColors(self, colorIds, colorArray, colorSet, rep)
Arguments:
	[in]	colorIds = MIntArray
	[in]	colorArray = MColorArray
	[in]	colorSet = MString
	[in]	rep = MFnMesh.MColorRepresentation

Sets the specified colors of specified channels for this
mesh.'''
        pass

    def getFaceVertexNormal(self, faceIndex, vertexIndex, space, normal): 
        '''getFaceVertexNormal(self, faceIndex, vertexIndex, space, normal)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	normal = MVector
	[in]	space = MSpace.Space

Return a per-vertex-per-face normal for a given face (polygon)
and given vertex.'''
        pass

    def getPointAtUV(self, polygonId, uvPoint, space, uvSet, tolerance, toThisPoint): 
        '''getPointAtUV(self, polygonId, uvPoint, space, uvSet, tolerance, toThisPoint)
Arguments:
	[in]	polygonId = int
	[out]	toThisPoint = MPoint
	[in]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString
	[in]	tolerance = float

Return the position of the point at the given UV value in the
current polygon.'''
        pass

    def setUVs(self, uArray, vArray, uvSet): 
        '''setUVs(self, uArray, vArray, uvSet)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	uvSet = MString

Sets all of the texture coordinates (uv's) for this mesh. The uv
arrays must be of equal size and must be at least as large as the
current UV set size. You can determine the UV set size by calling
 numUVs() 
for the default UV set, or numUVs(uvSet) for a named UV set.'''
        pass

    def getUVSetsInFamily(self, familyName, setNames): 
        '''getUVSetsInFamily(self, familyName, setNames)
Arguments:
	[in]	familyName = MString
	[out]	setNames = MStringArray

Get the names of the uv sets that belong to this set family.
Per-instance sets will have multiple sets in a family, with each
individual set applying to one or more instances. A set which is
shared across all instances will be the sole member of its family
and will share the same name as its family.'''
        pass

    def sortIntersectionFaceTriIds(self, faceIds, triIds): 
        '''sortIntersectionFaceTriIds(self, faceIds, triIds)
Arguments:
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray

Convenience routine for sorting faceIds or face/triangle ids
before passing them into the  closestIntersection() ,
 allIntersections() ,
or  anyIntersection() 
methods. When using an acceleration structure with the intersection
operation, it is essential that any faceId or faceId/triId arrays
be sorted properly to ensure optimal performance.'''
        pass

    def getNormals(self, space, normals): 
        '''getNormals(self, space, normals)
Arguments:
	[out]	normals = MFloatVectorArray
	[in]	space = MSpace.Space

This method copies the normal list for this mesh into the given
array. The normals are the per-polygon per-vertex normals. To find
the normal for a particular vertex-face, use  getFaceNormalIds() 
or  MItMeshPolygon::normalIndex 
to get the index into the array.'''
        pass

    def clearColors(self, colorSet): 
        '''clearColors(self, colorSet)
Arguments:
	[in]	colorSet = MString

This method clears out all color for the mesh, and leaves behind
an empty color set.'''
        pass

    def getPolygonUVid(self, polygonId, vertexIndex, uvSet, uvId): 
        '''getPolygonUVid(self, polygonId, vertexIndex, uvSet, uvId)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[out]	uvId = int
	[in]	uvSet = MString

Get the id of the specified texture coordinate for a vertex in a
polygon.'''
        pass

    def setFaceColor(self, color, faceIndex, rep): 
        '''setFaceColor(self, color, faceIndex, rep)
Arguments:
	[in]	color = MColor
	[in]	faceIndex = int
	[in]	rep = MFnMesh.MColorRepresentation

Set vertex-face Color of specified channels for all vertices on
this face.'''
        pass

    def numFaceVertices(self): 
        '''numFaceVertices(self) -> int
Returns: Returns:
The number of face-vertices for this mesh

Returns the number of face-vertices for this mesh.'''
        pass

    def setStringBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setStringBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MStringArray

Set a values for a string blind data on an array of components.
The arrays of values and components must be the same size.'''
        pass

    def numPolygons(self): 
        '''numPolygons(self) -> int
Returns: Returns:
The number of polygons for this mesh

Returns the number of polygons for this mesh.'''
        pass

    def kInternalPoint(self):
        '''This is an enum of SplitPlacement.
Description: Split at a point within a face.
Value: 1'''
        pass

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

    def kOnEdge(self):
        '''This is an enum of SplitPlacement.
Description: Split at a position along an edge.
Value: 0'''
        pass

    class SplitPlacement:
        '''Non-functional class.  Values for this enum:
        kInternalPoint
        kInvalid
        kOnEdge
'''
        def __init__(self):
            pass

    def freeCachedIntersectionAccelerator(self): 
        '''freeCachedIntersectionAccelerator(self)
If the mesh has a cached intersection accelerator structure,
then this routine forces it to be deleted. Ordinarily, these
structures are cached so that series of calls to the  closestIntersection() ,
 allIntersections() ,
and  anyIntersection() 
method can reuse the same structure. Once the client is finished
with these intersection operations, however, they are responsible
for freeing the acceleration structure, which is what this method
does.'''
        pass

    def intersect(self, raySource, rayDirection, tolerance, space, points, polygonIds): 
        '''intersect(self, raySource, rayDirection, tolerance, space, points, polygonIds) -> bool
Returns: Returns:


true The given ray intersects this polygon
false The given ray does not intersect this polygon

Arguments:
	[in]	raySource = MPoint
	[in]	rayDirection = MVector
	[out]	points = MPointArray
	[in]	tolerance = double
	[in]	space = MSpace.Space
	[out]	polygonIds = MIntArray

Determines whether the given ray intersects this polygon and if
so, returns the points of intersection. The points of intersection
will be in order of closest point to the raySource.'''
        pass

    def getBoolBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getBoolBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MIntArray

Get the blind data value for the specified blind data attribute
for all components of the given type. If the type of the attribute
is not correct, this method will fail.'''
        pass

    def createInPlace(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects): 
        '''createInPlace(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects)
Arguments:
	[in]	numVertices = int
	[in]	numPolygons = int
	[in]	vertexArray = MFloatPointArray
	[in]	polygonCounts = MIntArray
	[in]	polygonConnects = MIntArray

Replaces the existing polygonal mesh with a new one specified by
array of vertices and polygon connection information. This function
will then operate on the replacement surface.'''
        pass

    def getNormalIds(self, normalCounts, normals): 
        '''getNormalIds(self, normalCounts, normals)
Arguments:
	[out]	normalCounts = MIntArray
	[out]	normals = MIntArray

Return normal indices for all vertices for a all faces. The
normalIds can be used to index into an array returned by  MFnMesh::getNormals() ;'''
        pass

    def setEdgeSmoothing(self, edgeId, smooth): 
        '''setEdgeSmoothing(self, edgeId, smooth)
Arguments:
	[in]	edgeId = int
	[in]	smooth = bool

This method sets the specified edge to be hard or smooth (soft).
You must use the  cleanupEdgeSmoothing  method after all the
desired edges on your mesh have had setEdgeSmoothing done. Use the
 updateSurface  method to indicate the mesh needs to be
redrawn.'''
        pass

    def setInvisibleFaces(self, faceIds, makeVisible): 
        '''setInvisibleFaces(self, faceIds, makeVisible)
Arguments:
	[in]	faceIds = MUintArray
	[in]	makeVisible = bool

This method sets the specified faces of the mesh to be visible
or invisible. See the  getInvisibleFaces() 
method for a description of invisible faces.'''
        pass

    def isPolygonConvex(self, faceIndex): 
        '''isPolygonConvex(self, faceIndex) -> bool
Returns: Returns:


true The polygon is convex
false The edge is concave

Arguments:
	[in]	faceIndex = int

This method determines if the specified polygon is convex.'''
        pass

    def getRawPoints(self): 
        '''getRawPoints(self) -> float*

This method returns a pointer to the internal vertex list for
this mesh. The points are in local space.'''
        pass

    def stringBlindDataComponentId(self, compID, compType, blindDataId, attrName): 
        '''stringBlindDataComponentId(self, compID, compType, blindDataId, attrName) -> MString
Returns: Returns:
Blind data.

Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString

Get the blind data value for the specified blind data attribute
of the specified component. If the type of the attribute is not
correct, this method will fail.'''
        pass

    def getFaceVertexTangents(self, faceIndex, space, uvSet, tangents): 
        '''getFaceVertexTangents(self, faceIndex, space, uvSet, tangents)
Arguments:
	[in]	faceIndex = int
	[out]	tangents = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return all per-vertex-per-face tangents for a given face.'''
        pass

    def createColorSet(self, colorSetName, modifier, clamped, rep, instances): 
        '''createColorSet(self, colorSetName, modifier, clamped, rep, instances)
Arguments:
	[in]	colorSetName = MString
	[in]	modifier = MDGModifier
	[in]	clamped = bool
	[in]	rep = MFnMesh.MColorRepresentation
	[in]	instances = MUintArray

This method is not available in Python.'''
        pass

    def anyIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance): 
        '''anyIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance) -> bool

Arguments:
	[in]	raySource = MFloatPoint
	[in]	rayDirection = MFloatVector
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray
	[in]	idsSorted = bool
	[in]	space = MSpace.Space
	[in]	maxParam = float
	[in]	testBothDirections = bool
	[in]	accelParams = MMeshIsectAccelParams
	[in]	hitPoint = MFloatPoint
	[in]	hitRayParam = float
	[in]	hitFace = int
	[in]	hitTriangle = int
	[in]	hitBary1 = float
	[in]	hitBary2 = float
	[in]	tolerance = float

Finds any intersection of a ray starting at raySource and
travelling in rayDirection with the mesh. If faceIds is non-NULL
and triIds is NULL, then only the faces specified by faceIds will
be considered for intersection. If both faceIds and triIds are
non-NULL, then each pair of entries will be taken as a
(face,triangle) pair to be considered for intersection, where
triangles are numbered on each face starting from 0. Thus, the
face-triangle pair (10,0) means the first triangle on face 10. If
both faceIds and triIds are NULL, then all face-triangles in the
mesh will be considered.'''
        pass

    def getFaceUVSetNames(self, polygonId, setNames): 
        '''getFaceUVSetNames(self, polygonId, setNames)
Arguments:
	[in]	polygonId = int
	[out]	setNames = MStringArray

This method returns the list of UV sets mapped to a face.'''
        pass

    def copyUVSet(self, fromName, toName, modifier): 
        '''copyUVSet(self, fromName, toName, modifier)
Arguments:
	[in]	fromName = MString
	[in]	toName = MString
	[in]	modifier = MDGModifier

This method is not available in Python.'''
        pass

    def removeVertexColors(self, vertexList): 
        '''removeVertexColors(self, vertexList)
Arguments:
	[in]	vertexList = MIntArray

Remove color from these vertices.'''
        pass

    def isNormalLocked(self, normalId): 
        '''isNormalLocked(self, normalId) -> bool

Arguments:
	[in]	normalId = int

'''
        pass

    def numUVs(self, uvSet): 
        '''numUVs(self, uvSet) -> int
Returns: Returns:
The number of texture coordinates

Arguments:
	[in]	uvSet = MString

Returns the number of texture (uv) coordinates for this mesh.
The uv's are stored in a list which is referenced by polygons
requiring textures on a per-polygon per-vertex basis. This method
returns the number of elements in this list.'''
        pass

    def deleteFace(self, faceId, modifier): 
        '''deleteFace(self, faceId, modifier)
Arguments:
	[in]	faceId = int
	[in]	modifier = MDGModifier

Delete this face. The method will return failure if an attempt
is made to delete the last polygonal face in the object.'''
        pass

    def getRawNormals(self): 
        '''getRawNormals(self) -> float*

This method returns a pointer to the internal normal list for
this mesh. The normals are in local space and are the per-polygon
per-vertex normals. To find the normal for a particular
vertex-face, use  getFaceNormalIds() 
or  MItMeshPolygon::normalIndex 
to get the index into the array.'''
        pass

    def setIntBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setIntBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MIntArray

Set a values for an integer blind data on an array of
components. The arrays of values and components must be the same
size.'''
        pass

    def extrudeFaces(self, faceList, extrusionCount, translation, extrudeTogether): 
        '''extrudeFaces(self, faceList, extrusionCount, translation, extrudeTogether)
Arguments:
	[in]	faceList = MIntArray
	[in]	extrusionCount = int
	[in]	translation = MFloatVector
	[in]	extrudeTogether = bool

This function extrudes a set of faces. The resulting mesh will
have extra parallelograms coming out of the edges of the given
polygons going to the new extruded edges. The extrusionCount
argument is the number of subsequent extrusions per polygon and
represents the number of faces that will be created for each edge
of the polygons in the list.'''
        pass

    def setColor(self, colorId, color, colorSet, rep): 
        '''setColor(self, colorId, color, colorSet, rep)
Arguments:
	[in]	colorId = int
	[in]	color = MColor
	[in]	colorSet = MString
	[in]	rep = MFnMesh.MColorRepresentation

Sets the specified color values of specified channels. The
colorId is the element in the color list that will be set. If the
colorId is greater than or equal to  numColors() 
then the color list will be grown to accommodate the specified
color.'''
        pass

    def setFaceVertexNormal(self, normalIn, faceId, vertexId, space, modifier): 
        '''setFaceVertexNormal(self, normalIn, faceId, vertexId, space, modifier)
Arguments:
	[in]	normalIn = MVector
	[in]	faceId = int
	[in]	vertexId = int
	[in]	space = MSpace.Space
	[in]	modifier = MDGModifier

Set Normal for this face/vertex pair'''
        pass

    def deleteEdge(self, edgeId, modifier): 
        '''deleteEdge(self, edgeId, modifier)
Arguments:
	[in]	edgeId = int
	[in]	modifier = MDGModifier

Delete this edge.'''
        pass

    def currentColorSetName(self, instance): 
        '''currentColorSetName(self, instance) -> MString

Arguments:
	[in]	instance = int

Get the name of the "current" or "working" color set. The
"current" color set is the color set which is used for color
operations when no color set is explcitly specified.'''
        pass

    def getPolygonNormal(self, polygonId, space, normal): 
        '''getPolygonNormal(self, polygonId, space, normal)
Arguments:
	[in]	polygonId = int
	[out]	normal = MVector
	[in]	space = MSpace.Space

Return the normal at the given polygon. The returned normal is a
per-polygon normal. See the class description for more information
on normals.'''
        pass

    def setUV(self, uvId, u, v, uvSet): 
        '''setUV(self, uvId, u, v, uvSet)
Arguments:
	[in]	uvId = int
	[in]	u = float
	[in]	v = float
	[in]	uvSet = MString

Sets the specified texture coordinate. The uvId is the element
in the uv list that will be set. If the uvId is greater than or
equal to  numUVs() 
then the uv list will be grown to accommodate the specified uv. If
a named uv set is given, the largest uvId must be larger than
numUVs(uvSet).'''
        pass

    def assignUV(self, polygonId, vertexIndex, uvId, uvSet): 
        '''assignUV(self, polygonId, vertexIndex, uvId, uvSet)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[in]	uvId = int
	[in]	uvSet = MString

Maps a texture coordinate to a specified vertex of a
polygon.'''
        pass

    def getTriangles(self, triangleCounts, triangleVertices): 
        '''getTriangles(self, triangleCounts, triangleVertices)
Arguments:
	[out]	triangleCounts = MIntArray
	[out]	triangleVertices = MIntArray

Returns the number of triangles for every polygon face and the
vertex Ids of each triangle vertex. The triangleVertices array
holds each vertex for each triangle in sequence, so is three times
longer than the triangleCounts array'''
        pass

    def clearGlobalIntersectionAcceleratorInfo(self): 
        '''clearGlobalIntersectionAcceleratorInfo(self)
'''
        pass

    def polygonVertexCount(self, polygonId): 
        '''polygonVertexCount(self, polygonId) -> int
Returns: Returns:
The number of vertices for the specified polygon

Arguments:
	[in]	polygonId = int

Returns the number of vertices for the specified polygon.'''
        pass

    def isColorSetPerInstance(self, name): 
        '''isColorSetPerInstance(self, name) -> bool
Returns: Returns:
true if the set is per-instance

Arguments:
	[in]	name = MString

Return true if this color set is per-instance, and false if it
is shared across all instances. The name provided may be an
individual set name or a set family name.'''
        pass

    def getClosestNormal(self, toThisPoint, space, theNormal, closestPolygon): 
        '''getClosestNormal(self, toThisPoint, space, theNormal, closestPolygon)
Arguments:
	[in]	toThisPoint = MPoint
	[out]	theNormal = MVector
	[in]	space = MSpace.Space
	[out]	closestPolygon = int

Returns the closest point on this surface to the given point.
This method also returns the surface normal at that point.'''
        pass

    def getClosestPointAndNormal(self, toThisPoint, space, theClosestPoint, theNormal, closestPolygon): 
        '''getClosestPointAndNormal(self, toThisPoint, space, theClosestPoint, theNormal, closestPolygon)
Arguments:
	[in]	toThisPoint = MPoint
	[out]	theClosestPoint = MPoint
	[out]	theNormal = MVector
	[in]	space = MSpace.Space
	[out]	closestPolygon = int

Returns the closest point on this surface to the given point.
This method also returns the surface normal at that point.'''
        pass

    def getTangentId(self, faceIndex, vertexIndex): 
        '''getTangentId(self, faceIndex, vertexIndex) -> int

Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int

Return the tangent index for a given face vertex.'''
        pass

    def getVertexColors(self, colorSet, defaultUnsetColor, colors): 
        '''getVertexColors(self, colorSet, defaultUnsetColor, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor

Get colors for all Vertices of the given colorSet. If the
colorSet is not specified, the default color set will be used. If
no vertex/face has color for that vertex, the entry returned will
be defaultUnsetColor. If the defaultUnsetColor is not given, then
(-1, -1, -1, -1) will be used. If a color was set for some or all
the faces for that vertex, an average of those verted/face values
where the color has been set will be returned.'''
        pass

    def getPolygonTriangleVertices(self, polygonId, triangleId, vertexList): 
        '''getPolygonTriangleVertices(self, polygonId, triangleId, vertexList)
Arguments:
	[in]	polygonId = int
	[in]	triangleId = int
	[out]	vertexList = int3

This method retrieves the  object-relative
(mesh-relative/global)  vertex indices for the specified
triangle in the specified polygon. The indices refer to the
elements in the array returned by the 'getPoints' method.'''
        pass

    def cleanupEdgeSmoothing(self): 
        '''cleanupEdgeSmoothing(self)
This method updates the mesh after setEdgeSmoothing has been
done. This should be called only once, after all the desired edges
have been had their soothing set. If you don't call this method,
the normals may not be correct, and the object will look odd in
shaded mode.'''
        pass

    def createBlindDataType(self, blindDataId, longNames, shortNames, formatNames): 
        '''createBlindDataType(self, blindDataId, longNames, shortNames, formatNames)
Arguments:
	[in]	blindDataId = int
	[in]	longNames = MStringArray
	[in]	shortNames = MStringArray
	[in]	formatNames = MStringArray

Create a new blind data type. If the type id is already in use,
this method will fail. Format names must be one of "int" "float"
"double" "boolean" "string" "binary".'''
        pass

    def numEdges(self): 
        '''numEdges(self) -> int
Returns: Returns:
The number of edges for this mesh

Returns the number of edges for this mesh.'''
        pass

    def deleteColorSet(self, colorSetName, modifier, currentSelection): 
        '''deleteColorSet(self, colorSetName, modifier, currentSelection)
Arguments:
	[in]	colorSetName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList

Deletes a named color set from the object. If a color set with
the given name cannot be found, then no color set will be
deleted.'''
        pass

    def assignUVs(self, uvCounts, uvIds, uvSet): 
        '''assignUVs(self, uvCounts, uvIds, uvSet)
Arguments:
	[in]	uvCounts = MIntArray
	[in]	uvIds = MIntArray
	[in]	uvSet = MString

This method maps all texture coordinates for the mesh. The
setUV/setUVs method is used to create the texture coordinate table
for the mesh. After the table is created, this method is used to
map those values to each polygon on a per-vertex basis. The
setUV/setUVs method should be called before the assignUVs
method.'''
        pass

    def getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps): 
        '''getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps)
Arguments:
	[in]	instanceNumber = int
	[out]	sets = MObjectArray
	[out]	comps = MObjectArray
	[in]	renderableSetsOnly = bool

Returns all the sets connected to the specified instance of this
mesh. For each set in the "sets" array there is a corresponding
entry in the "comps" array which are all the components in that
set. If the entire object is in a set, then the corresponding entry
in the comps array will have no elements in it.'''
        pass

    def subdivideFaces(self, faceList, divisionCount): 
        '''subdivideFaces(self, faceList, divisionCount)
Arguments:
	[in]	faceList = MIntArray
	[in]	divisionCount = int

This function subdivides multiple faces. This method only
accepts faces that are three of four-sided. The operation adds a
vertex in the middle of each given face and connects it to the
middle of every edge in the given face. This results in three or
four new faces for each original face.'''
        pass

    def createColorSetWithName(self, colorSetName, modifier, instances): 
        '''createColorSetWithName(self, colorSetName, modifier, instances) -> MString
Returns: Returns:
The resulting name of the color set.

Arguments:
	[in]	colorSetName = MString
	[in]	modifier = MDGModifier
	[in]	instances = MUintArray

Create a new empty color set for this mesh. If the name passed
in is empty (zero length), or a color set with the same name
already exists, then a new unique name is generated and used as the
new color set's name.'''
        pass

    def getColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex): 
        '''getColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex)
Arguments:
	[in]	faceIndex = int
	[in]	localVertexIndex = int
	[out]	colorIndex = int
	[in]	colorSet = MString

Get an index into the array returned by getColors.'''
        pass

    def deleteUVSet(self, setName, modifier, currentSelection): 
        '''deleteUVSet(self, setName, modifier, currentSelection)
Arguments:
	[in]	setName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList

Deletes a named uv set from the object. If a uv set with the
given name cannot be found, then no uv set will be deleted.'''
        pass

    def getUVs(self, uvSet, uArray, vArray): 
        '''getUVs(self, uvSet, uArray, vArray)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray
	[in]	uvSet = MString

This method copies the texture coordinate list for this mesh
into the given uv arrays.'''
        pass

    def subdivideEdges(self, edgeList, divisionCount): 
        '''subdivideEdges(self, edgeList, divisionCount)
Arguments:
	[in]	edgeList = MIntArray
	[in]	divisionCount = int

This function subdivides edges at regular intervals. The
divisionCount argument is the number of subdivisions per edges and
represents the number of new vertices created on each edge.'''
        pass

    def create(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, uArray, vArray, parentOrOwner): 
        '''create(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, uArray, vArray, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kMeshData

Arguments:
	[in]	numVertices = int
	[in]	numPolygons = int
	[in]	vertexArray = MPointArray
	[in]	polygonCounts = MIntArray
	[in]	polygonConnects = MIntArray
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	parentOrOwner = MObject

Creates a new polygonal mesh given an array of vertices, polygon
connection information, UV information, and sets this function set
to operate on the new surface.'''
        pass

    def setCreaseEdges(self, edgeIds, creaseData): 
        '''setCreaseEdges(self, edgeIds, creaseData)
Arguments:
	[in]	edgeIds = MUintArray
	[in]	creaseData = MDoubleArray

This method sets the specified edges of the mesh as crease
edges.'''
        pass

    def getVertexNormal(self, vertexId, angleWeighted, space, normal): 
        '''getVertexNormal(self, vertexId, angleWeighted, space, normal)
Arguments:
	[in]	vertexId = int
	[in]	angleWeighted = bool
	[out]	normal = MVector
	[in]	space = MSpace.Space

Return the normal at the given vertex. The returned normal is a
single per-vertex normal, so unshared normals at a vertex will be
averaged. See the class description for more information on
normals.'''
        pass

    def getFaceVertexColors(self, colorSet, defaultUnsetColor, colors): 
        '''getFaceVertexColors(self, colorSet, defaultUnsetColor, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor

Get colors for all vertex/faces of the given color set. If the
color set is not specified, the default color set will be used. If
no vertex/face has color for that vertex, the entry returned will
be defaultUnsetColor. If defaultUnsetColor is not given, then (-1,
-1, -1, -1) will be used. If a color was set for some but not all
the faces for that vertex, the ones where the color has not been
explicitly set will have (0,0,0). If a vertex has shared color, the
same value will be set for all its vertes/faces.'''
        pass

    def getAssociatedUVSetInstances(self, uvSetName, instances): 
        '''getAssociatedUVSetInstances(self, uvSetName, instances)
Arguments:
	[in]	uvSetName = MString
	[out]	instances = MIntArray

Get a list of the instance numbers associated with this uv map.
If the uv map is shared across all instances, an empty array will
be returned.'''
        pass

    def setVertexColor(self, color, vertexIndex, modifier, rep): 
        '''setVertexColor(self, color, vertexIndex, modifier, rep)
Arguments:
	[in]	color = MColor
	[in]	vertexIndex = int
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation

Set color of specified channels for this vertex. The color is
set for the vertex-face in each face that the vertex belongs
to.'''
        pass

    def getColorSetNames(self, setNames): 
        '''getColorSetNames(self, setNames)
Arguments:
	[out]	setNames = MStringArray

Get the names of all of the colors sets on this object.'''
        pass

    def getDoubleBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getDoubleBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MDoubleArray

Get the blind data value for the specified blind data attribute
for all components of the given type. If the type of the attribute
is not correct, this method will fail.'''
        pass

    def getIntBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getIntBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MIntArray

Get the blind data value for the specified blind data attribute
of the given type of component. If the type of the attribute is not
correct, this method will fail.'''
        pass

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

'''
        pass

    def hasColorChannels(self, colorSet): 
        '''hasColorChannels(self, colorSet) -> bool
Returns: Returns:


true The color set has RGB components
false The color set doesn't have RGB components

Arguments:
	[in]	colorSet = MString

This method returns if the color set has RGB components.'''
        pass

    def setVertexNormal(self, normalIn, vertexId, space, modifier): 
        '''setVertexNormal(self, normalIn, vertexId, space, modifier)
Arguments:
	[in]	normalIn = MVector
	[in]	vertexId = int
	[in]	space = MSpace.Space
	[in]	modifier = MDGModifier

Set Shared Normal for this vertex'''
        pass

    def isUVSetPerInstance(self, name): 
        '''isUVSetPerInstance(self, name) -> bool
Returns: Returns:
true if the set is per-instance

Arguments:
	[in]	name = MString

Return true if this set is per-instance, and false if it is
shared across all instances. The name provided may be an individual
set name or a set family name.'''
        pass

    def duplicateFaces(self, faceList, translation): 
        '''duplicateFaces(self, faceList, translation)
Arguments:
	[in]	faceList = MIntArray
	[in]	translation = MFloatVector

This function duplicates a set of faces and detaches them from
the rest of the mesh. The resulting mesh will contain one more
independant piece of geometry.'''
        pass

    def getBinormals(self, space, uvSet, binormals): 
        '''getBinormals(self, space, uvSet, binormals)
Arguments:
	[out]	binormals = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return the binormal vectors for all face vertices.'''
        pass

    def setSomeUVs(self, uvIds, uArray, vArray, uvSet): 
        '''setSomeUVs(self, uvIds, uArray, vArray, uvSet)
Arguments:
	[in]	uvIds = MIntArray
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	uvSet = MString

Sets the specified texture coordinates (UV's) for this mesh. The
uv arrays and uvId array must be of equal size. If the largest uvId
in the array is larger than  numUVs() 
then the uv list for this mesh will be grown to accommodate the new
uv values. If a named uv set is given, the array will be grown when
the largest uvId is larger than numUVs(uvSet).'''
        pass

    def createUVSet(self, uvSetName, modifier, instances): 
        '''createUVSet(self, uvSetName, modifier, instances)
Arguments:
	[in]	uvSetName = MString
	[in]	modifier = MDGModifier
	[in]	instances = MUintArray

This method is not available in Python.'''
        pass

    def kIntersection(self):
        '''This is an enum of BoolOperation.
Description: Boolean interesection.
Value: 1'''
        pass

    def kUnion(self):
        '''This is an enum of BoolOperation.
Description: Boolean union.
Value: 3'''
        pass

    def kDifference(self):
        '''This is an enum of BoolOperation.
Description: Boolean difference.
Value: 2'''
        pass

    class BoolOperation:
        '''Non-functional class.  Values for this enum:
        kIntersection
        kUnion
        kDifference
'''
        def __init__(self):
            pass

    def isBlindDataTypeUsed(self, blindDataId): 
        '''isBlindDataTypeUsed(self, blindDataId) -> bool
Returns: Returns:
true: Id in use, false: id not in use

Arguments:
	[in]	blindDataId = int

Is this BlindData type id is already in use in this scene?'''
        pass

    def getUV(self, uvId, uvSet, u, v): 
        '''getUV(self, uvId, uvSet, u, v)
Arguments:
	[in]	uvId = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString

Get the value of the specified texture coordinate from this
mesh's uv list. The uvId is the element in the uv list that will be
retrieved.'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kMeshData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject

This method creates a copy of a given source mesh. After the
copy this function set will operate on the new mesh.'''
        pass

    def collapseFaces(self, faceList): 
        '''collapseFaces(self, faceList)
Arguments:
	[in]	faceList = MIntArray

This function collapse faces into vertices. Non-adjacent faces
will be collapsed individually so that each pieces of adjacent
faces turn into one vertex.'''
        pass

    def clearUVs(self, uvSet): 
        '''clearUVs(self, uvSet)
Arguments:
	[in]	uvSet = MString

This method clears out all texture coordinates for the mesh, and
leaves behind an empty UVset.'''
        pass

    def createUVSetWithName(self, uvSetName, modifier, instances): 
        '''createUVSetWithName(self, uvSetName, modifier, instances) -> MString
Returns: Returns:
The name used for the UV set. May be different then the given
name if a new name needed to be generated.

Arguments:
	[in]	uvSetName = MString
	[in]	modifier = MDGModifier
	[in]	instances = MUintArray

Create a new empty uv set for this mesh. If the name passed in
is empty (zero length), or a uv set with the same name already
exists, then a new unique name is generated and used as the new
uvset's name.'''
        pass

    def getSmoothMeshDisplayOptions(self, options): 
        '''getSmoothMeshDisplayOptions(self, options)
Arguments:
	[out]	options = MMeshSmoothOptions

Retrieve the current display smoothing options for the mesh'''
        pass

    def extrudeEdges(self, edgeList, extrusionCount, translation, extrudeTogether): 
        '''extrudeEdges(self, edgeList, extrusionCount, translation, extrudeTogether)
Arguments:
	[in]	edgeList = MIntArray
	[in]	extrusionCount = int
	[in]	translation = MFloatVector
	[in]	extrudeTogether = bool

This function extrudes edges. The resulting mesh will have extra
parallelograms coming out of the given edges and going to the new
extruded edges. The extrusionCount argument is the number of
subsequent extrusions per edges and represents the number of
polygons that will be created from each given edge to the extruded
edges.'''
        pass

    def hasAlphaChannels(self, colorSet): 
        '''hasAlphaChannels(self, colorSet) -> bool
Returns: Returns:


true The color set has Alpha component
false The color set doesn't have Alpha component

Arguments:
	[in]	colorSet = MString

This method returns true if the color set has Alpha
component.'''
        pass

    def allIntersections(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, sortHits, hitPoints, hitRayParams, hitFaces, hitTriangles, hitBary1s, hitBary2s, tolerance): 
        '''allIntersections(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, sortHits, hitPoints, hitRayParams, hitFaces, hitTriangles, hitBary1s, hitBary2s, tolerance) -> bool

Arguments:
	[in]	raySource = MFloatPoint
	[in]	rayDirection = MFloatVector
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray
	[in]	idsSorted = bool
	[in]	space = MSpace.Space
	[in]	maxParam = float
	[in]	testBothDirections = bool
	[in]	accelParams = MMeshIsectAccelParams
	[in]	sortHits = bool
	[in]	hitPoints = MFloatPointArray
	[in]	hitRayParams = MFloatArray
	[in]	hitFaces = MIntArray
	[in]	hitTriangles = MIntArray
	[in]	hitBary1s = MFloatArray
	[in]	hitBary2s = MFloatArray
	[in]	tolerance = float

Finds all intersections of a ray starting at raySource and
travelling in rayDirection with the mesh. If faceIds is non-NULL
and triIds is NULL, then only the faces specified by faceIds will
be considered for intersection. If both faceIds and triIds are
non-NULL, then each pair of entries will be taken as a
(face,triangle) pair to be considered for intersection, where
triangles are numbered on each face starting from 0. Thus, the
face-triangle pair (10,0) means the first triangle on face 10. If
both faceIds and triIds are NULL, then all face-triangles in the
mesh will be considered.'''
        pass

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

'''
        pass

    def getPoints(self, space, vertexArray): 
        '''getPoints(self, space, vertexArray)
Arguments:
	[out]	vertexArray = MPointArray
	[in]	space = MSpace.Space

This method copies the vertex list for this mesh into the given
point array.'''
        pass

    def getCurrentColorSetName(self, instance, setName): 
        '''getCurrentColorSetName(self, instance, setName)
Arguments:
	[out]	setName = MString
	[in]	instance = int

This method is not available in Python.'''
        pass

    def getUvShellsIds(self, uvSet, uvShellIds, nbUvShells): 
        '''getUvShellsIds(self, uvSet, uvShellIds, nbUvShells)
Arguments:
	[out]	uvShellIds = MIntArray
	[out]	nbUvShells = int
	[in]	uvSet = MString

Constructs an array of unique integer for each UV shell. This
method let the user identify each connected piece of UV.'''
        pass

    def getColors(self, colorSet, defaultUnsetColor, colorArray): 
        '''getColors(self, colorSet, defaultUnsetColor, colorArray)
Arguments:
	[out]	colorArray = MColorArray
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor

This method copies the color array for this mesh into the given
color array. Use the index returned by getColorIndex to access the
array. If the color is not set for a vertex, defaultUnsetColor will
be return. If defaultUnsetColor is not set, (0,0,0,1) will be
return.'''
        pass

    def setFaceColors(self, colors, faceList, rep): 
        '''setFaceColors(self, colors, faceList, rep)
Arguments:
	[in]	colors = MColorArray
	[in]	faceList = MIntArray
	[in]	rep = MFnMesh.MColorRepresentation

Set color of specified channels for these faces. The color will
be set for each vertex-face component of a face.'''
        pass

    def uniformGridParams(self, xDiv, yDiv, zDiv): 
        '''uniformGridParams(self, xDiv, yDiv, zDiv) -> MMeshIsectAccelParams

Arguments:
	[in]	xDiv = int
	[in]	yDiv = int
	[in]	zDiv = int

Creates a MMeshIsectAccelParams configuration object to pass to
the methods  MFnMesh::closestIntersection() ,
 MFnMesh::anyIntersection() ,
or  MFnMesh::allIntersections() .
This object specifies that a uniform voxel grid structure should be
used by the intersection routines to speed up their operation. This
object specifies the number of voxel cells to be used in the x, y,
and z dimensions. The grid acceleration structure will be cached
with the mesh, so that if the same MMeshIsectAccelParams
configuration is used on the next intersect call, the acceleration
structure will not need to be rebuilt.'''
        pass

    def unlockFaceVertexNormals(self, faceList, vertexList): 
        '''unlockFaceVertexNormals(self, faceList, vertexList)
Arguments:
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray

Unlock Normals for these face/vertex pairs'''
        pass

    def setBoolBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setBoolBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MIntArray

Set a values for a boolean blind data on an array of components.
The arrays of values and components must be the same size.'''
        pass

    def getUVAtPoint(self, pt, space, uvSet, closestPolygon, uvPoint): 
        '''getUVAtPoint(self, pt, space, uvSet, closestPolygon, uvPoint)
Arguments:
	[in]	pt = MPoint
	[out]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString
	[in]	closestPolygon = int

Find the point closet to the given point, and return the UV
value at that point.'''
        pass

    def getAssignedUVs(self, uvSet, uvCounts, uvIds): 
        '''getAssignedUVs(self, uvSet, uvCounts, uvIds)
Arguments:
	[out]	uvCounts = MIntArray
	[out]	uvIds = MIntArray
	[in]	uvSet = MString

Get assigned UVs. This method finds all texture coordinates for
the mesh that have been mapped, and returns them in the same format
as the assignUVs.'''
        pass

    def getHoles(self, holeInfoArray, holeVertexArray): 
        '''getHoles(self, holeInfoArray, holeVertexArray) -> int

Arguments:
	[in]	holeInfoArray = MIntArray
	[in]	holeVertexArray = MIntArray

Retrieves a list of the holes in the polygon.'''
        pass

    def setCurrentColorSetName(self, setName, modifier, currentSelection): 
        '''setCurrentColorSetName(self, setName, modifier, currentSelection)
Arguments:
	[in]	setName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList

Set the "current" or "working" color set for this object. The
"current" color set is the set to use by functions that do not have
a specific color set defined.'''
        pass

    def getCreaseVertices(self, vertexIds, creaseData): 
        '''getCreaseVertices(self, vertexIds, creaseData)
Arguments:
	[out]	vertexIds = MUintArray
	[out]	creaseData = MDoubleArray

This method returns the crease vertices of the mesh, and also
the crease data associated with those vertices.'''
        pass

    def kRGBA(self):
        '''This is an enum of MColorRepresentation.
Description: Red, green, blue and alpha.
Value: 4'''
        pass

    def kAlpha(self):
        '''This is an enum of MColorRepresentation.
Description: Alpha only.
Value: 1'''
        pass

    def kRGB(self):
        '''This is an enum of MColorRepresentation.
Description: Red, green and blue only.
Value: 3'''
        pass

    class MColorRepresentation:
        '''Non-functional class.  Values for this enum:
        kRGBA
        kAlpha
        kRGB
'''
        def __init__(self):
            pass

    def setSmoothMeshDisplayOptions(self, options): 
        '''setSmoothMeshDisplayOptions(self, options)
Arguments:
	[in]	options = MMeshSmoothOptions

Sets the current display smoothing options for the mesh'''
        pass

    def setFaceVertexColors(self, colors, faceList, vertexList, modifier, rep): 
        '''setFaceVertexColors(self, colors, faceList, vertexList, modifier, rep)
Arguments:
	[in]	colors = MColorArray
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation

Set colors of specified channels for these face/vertex
pairs.'''
        pass

    def getFaceVertexNormals(self, faceIndex, space, normals): 
        '''getFaceVertexNormals(self, faceIndex, space, normals)
Arguments:
	[in]	faceIndex = int
	[out]	normals = MFloatVectorArray
	[in]	space = MSpace.Space

Return all per-vertex-per-face normals for a given face.'''
        pass

    def setDoubleBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setDoubleBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MDoubleArray

Set a values for a double blind data on an array of components.
The arrays of values and components must be the same size.'''
        pass

    def split(self, placements, edgeList, edgeFactors, internalPoints): 
        '''split(self, placements, edgeList, edgeFactors, internalPoints)
Arguments:
	[in]	placements = MIntArray
	[in]	edgeList = MIntArray
	[in]	edgeFactors = MFloatArray
	[in]	internalPoints = MFloatPointArray

This function splits a set of edges and faces in a continuous
manner.'''
        pass

    def getFaceVertexBinormal(self, faceIndex, vertexIndex, space, uvSet, binormal): 
        '''getFaceVertexBinormal(self, faceIndex, vertexIndex, space, uvSet, binormal)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	binormal = MVector
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return the binormal vector at a given face vertex.'''
        pass

    def getBlindDataTypes(self, compType, blindDataIds): 
        '''getBlindDataTypes(self, compType, blindDataIds)
Arguments:
	[in]	compType = MFn.Type
	[out]	blindDataIds = MIntArray

Get the list of blind data ID's associated with the given
component type on this mesh. (e.g. all blind data ID's present on
vertex compontents)'''
        pass

    def hasBlindData(self, compType): 
        '''hasBlindData(self, compType) -> bool
Returns: Returns:
true: has the specified blind data, false: does not

Arguments:
	[in]	compType = MFn.Type

Does any component of this type have any blind data. (.e. is
there any vertex blind data on this mesh?)'''
        pass

    def getClosestPoint(self, toThisPoint, space, theClosestPoint, closestPolygon): 
        '''getClosestPoint(self, toThisPoint, space, theClosestPoint, closestPolygon)
Arguments:
	[in]	toThisPoint = MPoint
	[out]	theClosestPoint = MPoint
	[in]	space = MSpace.Space
	[out]	closestPolygon = int

Returns the closest point on this surface to the given
point.'''
        pass

    def setFaceVertexNormals(self, normalsIn, faceList, vertexList, space): 
        '''setFaceVertexNormals(self, normalsIn, faceList, vertexList, space)
Arguments:
	[in]	normalsIn = MVectorArray
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray
	[in]	space = MSpace.Space

Set Normals for the given face/vertex pairs. Note that if there
is a vertex-face mismatch anywhere in the list, this method will
return an error, and not set any of the normals.'''
        pass

    def autoUniformGridParams(self): 
        '''autoUniformGridParams(self) -> MMeshIsectAccelParams

Creates a MMeshIsectAccelParams configuration object to pass to
the methods  MFnMesh::closestIntersection() ,
 MFnMesh::anyIntersection() ,
or  MFnMesh::allIntersections() .
This object specifies that a uniform voxel grid structure should be
used by the intersection routines to speed up their operation, and
that the system should automatically determine the number of voxel
cells to use based on the density of triangles in the mesh. The
grid acceleration structure will be cached with the mesh, so that
if the same MMeshIsectAccelParams configuration is used on the next
intersect call, the acceleration structure will not need to be
rebuilt.'''
        pass

    def syncObject(self): 
        '''syncObject(self)
If a non-api operation happens that many have changed the
underlying Maya object wrapped by this api object, make sure that
the api object references a valid maya object. In particular this
call should be used if you are calling mel commands from your
plugin. Note that this only applies for mesh shapes: in a plugin
node where the dataMesh is being accessed directly this is not
necessary.'''
        pass

    def removeFaceVertexColors(self, faceList, vertexList): 
        '''removeFaceVertexColors(self, faceList, vertexList)
Arguments:
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray

Remove colors for these face/vertex pairs'''
        pass

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

'''
        pass

    def lockFaceVertexNormals(self, faceList, vertexList): 
        '''lockFaceVertexNormals(self, faceList, vertexList)
Arguments:
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray

Lock Normals for these face/vertex pairs'''
        pass

    def numNormals(self): 
        '''numNormals(self) -> int
Returns: Returns:
The number of per-polygon per-vertex normals

Returns the number of per-polygon per-vertex normals for this
mesh. This number will correspond to the length of the normal array
returned by getNormals( normalArray, space ).'''
        pass

    def getFaceVertexBinormals(self, faceIndex, space, uvSet, binormals): 
        '''getFaceVertexBinormals(self, faceIndex, space, uvSet, binormals)
Arguments:
	[in]	faceIndex = int
	[out]	binormals = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return all per-vertex-per-face binormals for a given face.'''
        pass

    def setVertexNormals(self, normalsIn, vertexList, space): 
        '''setVertexNormals(self, normalsIn, vertexList, space)
Arguments:
	[in]	normalsIn = MVectorArray
	[in]	vertexList = MIntArray
	[in]	space = MSpace.Space

Set Shared Normals for these vertices. The length of the
normalsIn array should be same as the length of the vertexList
array.'''
        pass

    def getUVSetNames(self, setNames): 
        '''getUVSetNames(self, setNames)
Arguments:
	[out]	setNames = MStringArray

Get the names of all of the uv sets on this object.'''
        pass

    def getAssociatedColorSetInstances(self, colorSetName, instances): 
        '''getAssociatedColorSetInstances(self, colorSetName, instances)
Arguments:
	[in]	colorSetName = MString
	[out]	instances = MIntArray

Get a list of the instance numbers associated with this color
map. If the color map is shared across all instances, an empty
array will be returned.'''
        pass

    def generateSmoothMesh(self, parentOrOwner, options): 
        '''generateSmoothMesh(self, parentOrOwner, options) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kMeshData

Arguments:
	[in]	parentOrOwner = MObject
	[in]	options = MMeshSmoothOptions

Creates a new polygonal mesh using either the Smooth Mesh
Preview attributes of this mesh or a set of options specified in an
 MMeshSmoothOptions 
object. Unlike the  MFnMesh::create 
functions, this function does not set this function set to operate
on the new surface.'''
        pass

    def setPoints(self, space, vertexArray): 
        '''setPoints(self, space, vertexArray)
Arguments:
	[out]	vertexArray = MPointArray
	[in]	space = MSpace.Space

This method copies the points in the given point array to the
vertices of this mesh.'''
        pass

    def getPolygonUV(self, polygonId, vertexIndex, uvSet, u, v): 
        '''getPolygonUV(self, polygonId, vertexIndex, uvSet, u, v)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString

Get the value of the specified texture coordinate for a vertex
in a polygon. Since texture coordinates (uv's) are stored
per-polygon per-vertex you must specify both the polygon and the
vertex that the u and v values are mapped to.'''
        pass

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

Retrieves a string that describes the systemwide resource usage
for cached mesh intersection accelerators. The string will be
formatted similar to:'''
        pass

    def getColorSetFamilyNames(self, familyNames): 
        '''getColorSetFamilyNames(self, familyNames)
Arguments:
	[out]	familyNames = MStringArray

Get the names of all of the color set families on this object. A
color set family is a set of per-instance sets with the same name
with each individual set applying to one or more instances. A set
which is shared across all instances will be the sole member of its
family.'''
        pass

    def extractFaces(self, faceList, translation): 
        '''extractFaces(self, faceList, translation)
Arguments:
	[in]	faceList = MIntArray
	[in]	translation = MFloatVector

This function detaches a set of faces from the mesh so that the
resulting mesh will contain one more independant piece of geometry
and leaves a hole where the faces use to be.'''
        pass

    def getBlindDataFaceVertexIndices(self, blindDataIndex, faceIndex, vertexIndex): 
        '''getBlindDataFaceVertexIndices(self, blindDataIndex, faceIndex, vertexIndex)
Arguments:
	[out]	blindDataIndex = int
	[out]	faceIndex = int
	[out]	vertexIndex = int

Get the face and vertex indices from the face-vertex blind data
index.'''
        pass

    def setIsColorClamped(self, colorSet, clamped): 
        '''setIsColorClamped(self, colorSet, clamped)
Arguments:
	[in]	colorSet = MString
	[in]	clamped = bool

Set the color set to be clamped.'''
        pass

    def getColorSetsInFamily(self, familyName, setNames): 
        '''getColorSetsInFamily(self, familyName, setNames)
Arguments:
	[out]	familyName = MString
	[out]	setNames = MStringArray

Get the names of the color sets that belong to this set family.
Per-instance sets will have multiple sets in a family, with each
individual set applying to one or more instances. A set which is
shared across all instances will be the sole member of its family
and will share the same name as its family.'''
        pass

    def setBinaryBlindData(self, compID, compType, blindDataId, attrName, data, length): 
        '''setBinaryBlindData(self, compID, compType, blindDataId, attrName, data, length)
Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = char
	[in]	length = int

Set a value for a binary blind data attribute.'''
        pass

    def renameUVSet(self, origName, newName, modifier): 
        '''renameUVSet(self, origName, newName, modifier)
Arguments:
	[in]	origName = MString
	[in]	newName = MString
	[in]	modifier = MDGModifier

Renames a uv set from one name to another for this mesh. The
original name must exist, and the new name cannot be the same name
as one that already exists. In these cases the uv set will not be
renamed.'''
        pass

    def getCreaseEdges(self, edgeIds, creaseData): 
        '''getCreaseEdges(self, edgeIds, creaseData)
Arguments:
	[out]	edgeIds = MUintArray
	[out]	creaseData = MDoubleArray

This method returns the crease edges of the mesh, and also the
crease data associated with those edges.'''
        pass

class MFnMeshData:
    '''Mesh function set for dependency node data.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: Returns:
The new MObject

Create a new  MObject , attach it to this instance and
initialize it with a data block capable of holding a Mesh.'''
        pass

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

'''
        pass

class MFnMessageAttribute:
    '''Message attribute function set.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self, fullName, briefName): 
        '''create(self, fullName, briefName) -> MObject
Returns: Returns:
The newly created Message attribute object.

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString

Creates a Message attribute object.'''
        pass

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

'''
        pass

class MFnNonAmbientLight:
    '''Manage Non-ambient Light dependency Nodes.'''
    def __init__(self):
        pass


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

'''
        pass

    def setDecayRate(self, decay_rate): 
        '''setDecayRate(self, decay_rate)
Arguments:
	[in]	decay_rate = short

Sets the value of the "decayRate" attribute of a non-ambient
light node.'''
        pass

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

'''
        pass

    def decayRate(self): 
        '''decayRate(self) -> short
Returns: Returns:
The value of the "decayRate" attribute of the non-ambient light
node.

Retrieves the value of the "decayRate" attribute of a
non-ambient light node. This attribute determines the type of decay
for the light.'''
        pass

class MFnNonExtendedLight:
    '''Manage Non-extended Light dependency Nodes.'''
    def __init__(self):
        pass


    def setCastSoftShadows(self, cast_soft_shadows): 
        '''setCastSoftShadows(self, cast_soft_shadows)
Arguments:
	[in]	cast_soft_shadows = bool

Sets the value of the "castSoftShadows" attribute of a
non-extended light node.'''
        pass

    def depthMapResolution(self): 
        '''depthMapResolution(self) -> short
Returns: Returns:
The value of the "depthMapResolution" attribute of the light
node.

Retrieves the value of the "depthMapResolution" attribute of a
light node. This attribute determines the resolution of the depth
map for this light.'''
        pass

    def setDepthMapResolution(self, depth_map_resolution): 
        '''setDepthMapResolution(self, depth_map_resolution)
Arguments:
	[in]	depth_map_resolution = short

Sets the value of the "depthMapResolution" attribute of a light
node.'''
        pass

    def setDepthMapFocus(self, depth_map_focus): 
        '''setDepthMapFocus(self, depth_map_focus)
Arguments:
	[in]	depth_map_focus = float

Sets the value of the "depthMapFocus" attribute of a light
node.'''
        pass

    def setUseDepthMapShadows(self, use_depth_map): 
        '''setUseDepthMapShadows(self, use_depth_map)
Arguments:
	[in]	use_depth_map = bool

Sets the value of the "useDepthMapShadows" attribute of a
non-extended light node.'''
        pass

    def depthMapWidthFocus(self): 
        '''depthMapWidthFocus(self) -> float
Returns: Returns:
The value of the "depthMapWidthFocus" attribute of the light
node.

Retrieves the value of the "depthMapWidthFocus" attribute of a
light node. This attribute is used to scale the depth map within
the area of the light's illumination.'''
        pass

    def depthMapBias(self): 
        '''depthMapBias(self) -> float
Returns: Returns:
The value of the "depthMapBias" attribute of the light
node.

Retrieves the value of the "depthMapBias" attribute of a light
node. This attribute represents the depth bias applied in depth map
shadow computations to prevent self-shadowing artifacts.'''
        pass

    def setDepthMapBias(self, depth_map_bias): 
        '''setDepthMapBias(self, depth_map_bias)
Arguments:
	[in]	depth_map_bias = float

Sets the value of the "depthMapBias" attribute of a light
node.'''
        pass

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

'''
        pass

    def setShadowRadius(self, shadow_radius): 
        '''setShadowRadius(self, shadow_radius)
Arguments:
	[in]	shadow_radius = float

Sets the value of the "shadowRadius" attribute of a non-extended
light node.'''
        pass

    def shadowRadius(self): 
        '''shadowRadius(self) -> float
Returns: Returns:
The value of the "shadowRadius" attribute of the non-extended
light node.

Retrieves the value of the "shadowRadius" attribute of a
non-extended light node. This attribute represents the radius of
the light used when computing soft shadows. Higher radius values
result in more extended soft shadows.'''
        pass

    def setDepthMapFilterSize(self, depth_map_filter_size): 
        '''setDepthMapFilterSize(self, depth_map_filter_size)
Arguments:
	[in]	depth_map_filter_size = short

Sets the value of the "depthMapFilterSize" attribute of a light
node.'''
        pass

    def depthMapFilterSize(self): 
        '''depthMapFilterSize(self) -> short
Returns: Returns:
The value of the "depthMapFilterSize" attribute of the light
node.

Retrieves the value of the "depthMapFilterSize" attribute of a
light node. This attribute determines the size of the filter used
in depth map shadow computations for the light.'''
        pass

    def depthMapFocus(self): 
        '''depthMapFocus(self) -> float
Returns: Returns:
The value of the "depthMapFocus" attribute of the light
node.

Retrieves the value of the "depthMapFocus" attribute of a light
node. This attribute represents the depth map's field of view.'''
        pass

    def setDepthMapWidthFocus(self, depth_map_width_focus): 
        '''setDepthMapWidthFocus(self, depth_map_width_focus)
Arguments:
	[in]	depth_map_width_focus = float

Sets the value of the "depthMapWidthFocus" attribute of a light
node.'''
        pass

    def useDepthMapShadows(self): 
        '''useDepthMapShadows(self) -> bool
Returns: Returns:
The value of the "useDepthMapShadows" attribute of the
non-extended light node.

Retrieves the value of the "useDepthMapShadows" attribute of a
non-extended light node. This attribute determines whether or not a
depth map will be used in shadow computations for this light.'''
        pass

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

'''
        pass

    def useDepthMapAutoFocus(self): 
        '''useDepthMapAutoFocus(self) -> bool
Returns: Returns:
The value of the "useDepthMapAutoFocus" attribute of the
non-extended light node.

Retrieves the value of the "useDepthMapAutoFocus" attribute of a
non-extended light node. This attribute determines whether to
automatically scale the depth map so that it only fills the area of
the light's illumination that contains shadow casting objects.'''
        pass

    def setUseDepthMapAutoFocus(self, use_depth_map_auto_focus): 
        '''setUseDepthMapAutoFocus(self, use_depth_map_auto_focus)
Arguments:
	[in]	use_depth_map_auto_focus = bool

Sets the value of the "useDepthMapAutoFocus" attribute of a
non-extended light node.'''
        pass

    def castSoftShadows(self): 
        '''castSoftShadows(self) -> bool
Returns: Returns:
The value of the "castSoftShadows" attribute of the
non-extended light node.

Retrieves the value of the "castSoftShadows" attribute of a
non-extended light node. This attribute determines whether or not
the light casts soft shadows.'''
        pass

class MFnNumericAttribute:
    '''Numeric attribute function set.'''
    def __init__(self):
        pass


    def createColor(self, full, brief): 
        '''createColor(self, full, brief) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString

Create a new color attribute and return it as an  MObject . The names of child
attributes will have "r", "g" and "b" appended to both the full and
brief names.'''
        pass

    def setMin(self, min1, min2, min3): 
        '''setMin(self, min1, min2, min3)
Arguments:
	[in]	min1 = double
	[in]	min2 = double
	[in]	min3 = double

Set the minimum values for the three children (all double
attributes) of this compound attribute.'''
        pass

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

Determine whether or not this double attribute has a soft
minimum value set.'''
        pass

    def unitType(self): 
        '''unitType(self) -> MFnNumericData.Type

Return the unit type of this attribute.'''
        pass

    def getMin(self, min1, min2, min3): 
        '''getMin(self, min1, min2, min3)
Arguments:
	[out]	min1 = double
	[out]	min2 = double
	[out]	min3 = double

Return the minimum values for the three children (all double
attributes) of this compound attribute.'''
        pass

    def createAddr(self, full, brief, defaultValue): 
        '''createAddr(self, full, brief, defaultValue) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	defaultValue = void

Create a new address attribute and return it as an  MObject .'''
        pass

    def getMax(self, max1, max2, max3): 
        '''getMax(self, max1, max2, max3)
Arguments:
	[out]	max1 = double
	[out]	max2 = double
	[out]	max3 = double

Return the maximum values for the three children (all double
attributes) of this compound attribute.'''
        pass

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

Determine whether or not this double attribute has a soft
maximum value set.'''
        pass

    def create(self, full, brief, child1, child2, child3): 
        '''create(self, full, brief, child1, child2, child3) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	child1 = MObject
	[in]	child2 = MObject
	[in]	child3 = MObject

Create a new numeric attribute and return it as an  MObject . This form of the create
method allows the creation of compound attributes out of numeric
attributes. All attributes passed in must be of the same type (eg
all of type kDouble). The child1, child2, and child3 (child3 can be
ommitted if only two children are desired) parameters represent
numeric attributes created previous via the other form of the
create method.'''
        pass

    def setMax(self, max1, max2, max3): 
        '''setMax(self, max1, max2, max3)
Arguments:
	[in]	max1 = double
	[in]	max2 = double
	[in]	max3 = double

Set the maximum values for the three children (all double
attributes) of this compound attribute.'''
        pass

    def setSoftMax(self, max): 
        '''setSoftMax(self, max)
Arguments:
	[in]	max = double

Set the soft maximum value for this double attribute.'''
        pass

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

'''
        pass

    def setDefault(self, def1): 
        '''setDefault(self, def1)
Arguments:
	[in]	def1 = void

Set a new default value for this address attribute.'''
        pass

    def getDefault(self, def1): 
        '''getDefault(self, def1)
Arguments:
	[out]	def1 = void

Get the default value for this address attribute.'''
        pass

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

Determine whether or not this attribute has a maximum value
set.'''
        pass

    def setSoftMin(self, min): 
        '''setSoftMin(self, min)
Arguments:
	[in]	min = double

Set the soft minimum value for this double attribute.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject

Arguments:
	[in]	index = int

Return the indicated child attribute as an  MObject . No index checking is done by
this routine, so you must ensure that the index provided is
valid.'''
        pass

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

Return the minimum value for this double attribute.'''
        pass

    def createPoint(self, full, brief): 
        '''createPoint(self, full, brief) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString

Create a new point attribute and return it as an  MObject . The names of child
attributes will have "x", "y" and "z" appended to both the full and
brief names.'''
        pass

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

'''
        pass

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

Return the maximum value for this double attribute.'''
        pass

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

Determine whether or not this attribute has a minimum value
set.'''
        pass

class MFnNumericData:
    '''Numeric data function set.'''
    def __init__(self):
        pass


    def getData2Int(self, val1, val2): 
        '''getData2Int(self, val1, val2)
Arguments:
	[out]	val1 = int
	[out]	val2 = int

Gets the stored value of this data object as a pair of int
integers. The data object must have been created as a pair of int
integers for this to succeed.'''
        pass

    def numericType(self): 
        '''numericType(self) -> MFnNumericData.Type
Returns: Returns:
Type of data

Returns the type of the numeric data object.'''
        pass

    def setData4Double(self, val1, val2, val3, val4): 
        '''setData4Double(self, val1, val2, val3, val4)
Arguments:
	[in]	val1 = double
	[in]	val2 = double
	[in]	val3 = double
	[in]	val4 = double

Sets the stored value of this data object as a quadruple of
doubles. The data object must have been created as a quadruple of
doubles for this to succeed.'''
        pass

    def setData2Int(self, val1, val2): 
        '''setData2Int(self, val1, val2)
Arguments:
	[in]	val1 = int
	[in]	val2 = int

Sets the stored value of this data object as a pair of int
integers. The data object must have been created as a pair of int
integers for this to succeed.'''
        pass

    def setData3Short(self, val1, val2, val3): 
        '''setData3Short(self, val1, val2, val3)
Arguments:
	[in]	val1 = short
	[in]	val2 = short
	[in]	val3 = short

Sets the stored value of this data object as a triple of short
integers. The data object must have been created as a triple of
short integers for this to succeed.'''
        pass

    def k3Double(self):
        '''This is an enum of Type.
Description: Three doubles.
Value: 15'''
        pass

    def k3Long(self):
        '''This is an enum of Type.
Description: Three longs. Same as 3 ints since "long" is not
platform-consistent.
Value: 9'''
        pass

    def kByte(self):
        '''This is an enum of Type.
Description: One byte.
Value: 2'''
        pass

    def kDouble(self):
        '''This is an enum of Type.
Description: One double.
Value: 13'''
        pass

    def k3Int(self):
        '''This is an enum of Type.
Description: Three ints.
Value: 9'''
        pass

    def k4Double(self):
        '''This is an enum of Type.
Description: Four doubles.
Value: 16'''
        pass

    def kBoolean(self):
        '''This is an enum of Type.
Description: Boolean.
Value: 1'''
        pass

    def kShort(self):
        '''This is an enum of Type.
Description: One short.
Value: 4'''
        pass

    def k2Float(self):
        '''This is an enum of Type.
Description: Two floats.
Value: 11'''
        pass

    def kFloat(self):
        '''This is an enum of Type.
Description: One float.
Value: 10'''
        pass

    def kLong(self):
        '''This is an enum of Type.
Description: One long. Same as int since "long" is not
platform-consistent.
Value: 7'''
        pass

    def k3Float(self):
        '''This is an enum of Type.
Description: Three floats.
Value: 12'''
        pass

    def k3Short(self):
        '''This is an enum of Type.
Description: Three shorts.
Value: 6'''
        pass

    def k2Short(self):
        '''This is an enum of Type.
Description: Two shorts.
Value: 5'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Last value. Does not represent a real type, but can be used to
loop on all possible types.
Value: 18'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: Invalid data.
Value: 0'''
        pass

    def k2Int(self):
        '''This is an enum of Type.
Description: Two ints.
Value: 8'''
        pass

    def kInt(self):
        '''This is an enum of Type.
Description: One int.
Value: 7'''
        pass

    def kAddr(self):
        '''This is an enum of Type.
Description: An address.
Value: 17'''
        pass

    def k2Double(self):
        '''This is an enum of Type.
Description: Two doubles.
Value: 14'''
        pass

    def kChar(self):
        '''This is an enum of Type.
Description: One character.
Value: 3'''
        pass

    def k2Long(self):
        '''This is an enum of Type.
Description: Two longs. Same as 2 ints since "long" is not
platform-consistent.
Value: 8'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        k3Double
        k3Long
        kByte
        kDouble
        k3Int
        k4Double
        kBoolean
        kShort
        k2Float
        kFloat
        kLong
        k3Float
        k3Short
        k2Short
        kLast
        kInvalid
        k2Int
        kInt
        kAddr
        k2Double
        kChar
        k2Long
'''
        def __init__(self):
            pass

    def setData2Float(self, val1, val2): 
        '''setData2Float(self, val1, val2)
Arguments:
	[in]	val1 = float
	[in]	val2 = float

Sets the stored value of this data object as a pair of floats.
The data object must have been created as a pair of floats for this
to succeed.'''
        pass

    def create(self, dataType): 
        '''create(self, dataType) -> MObject
Returns: Returns:
A pointer to the new object

Arguments:
	[in]	dataType = MFnNumericData.Type

Creates a new data object of the given type. Only pair and
triples of numeric data may be created (eg k3Float).'''
        pass

    def getData2Double(self, val1, val2): 
        '''getData2Double(self, val1, val2)
Arguments:
	[out]	val1 = double
	[out]	val2 = double

Gets the stored value of this data object as a pair of doubles.
The data object must have been created as a pair of doubles for
this to succeed.'''
        pass

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

'''
        pass

    def setData2Double(self, val1, val2): 
        '''setData2Double(self, val1, val2)
Arguments:
	[in]	val1 = double
	[in]	val2 = double

Sets the stored value of this data object as a pair of doubles.
The data object must have been created as a pair of doubles for
this to succeed.'''
        pass

    def getData4Double(self, val1, val2, val3, val4): 
        '''getData4Double(self, val1, val2, val3, val4)
Arguments:
	[out]	val1 = double
	[out]	val2 = double
	[out]	val3 = double
	[out]	val4 = double

Gets the stored value of this data object as a quadruple of
doubles. The data object must have been created as a quadruple of
doubles for this to succeed.'''
        pass

    def getData3Float(self, val1, val2, val3): 
        '''getData3Float(self, val1, val2, val3)
Arguments:
	[out]	val1 = float
	[out]	val2 = float
	[out]	val3 = float

Gets the stored value of this data object as a triple of floats.
The data object must have been created as a triple of floats for
this to succeed.'''
        pass

    def getData2Float(self, val1, val2): 
        '''getData2Float(self, val1, val2)
Arguments:
	[out]	val1 = float
	[out]	val2 = float

Gets the stored value of this data object as a pair of floats.
The data object must have been created as a pair of floats for this
to succeed.'''
        pass

    def setData3Int(self, val1, val2, val3): 
        '''setData3Int(self, val1, val2, val3)
Arguments:
	[in]	val1 = int
	[in]	val2 = int
	[in]	val3 = int

Sets the stored value of this data object as a triple of int
integers. The data object must have been created as a triple of int
integers for this to succeed.'''
        pass

    def getData3Int(self, val1, val2, val3): 
        '''getData3Int(self, val1, val2, val3)
Arguments:
	[out]	val1 = int
	[out]	val2 = int
	[out]	val3 = int

Gets the stored value of this data object as a triple of int
integers. The data object must have been created as a triple of int
integers for this to succeed.'''
        pass

    def setData3Double(self, val1, val2, val3): 
        '''setData3Double(self, val1, val2, val3)
Arguments:
	[in]	val1 = double
	[in]	val2 = double
	[in]	val3 = double

Sets the stored value of this data object as a triple of
doubles. The data object must have been created as a triple of
doubles for this to succeed.'''
        pass

    def getData3Double(self, val1, val2, val3): 
        '''getData3Double(self, val1, val2, val3)
Arguments:
	[out]	val1 = double
	[out]	val2 = double
	[out]	val3 = double

Gets the stored value of this data object as a triple of
doubles. The data object must have been created as a triple of
doubles for this to succeed.'''
        pass

    def getData2Short(self, val1, val2): 
        '''getData2Short(self, val1, val2)
Arguments:
	[out]	val1 = short
	[out]	val2 = short

Gets the stored value of this data object as a pair of short
integers. The data object must have been created as a pair of short
integers for this to succeed.'''
        pass

    def setData3Float(self, val1, val2, val3): 
        '''setData3Float(self, val1, val2, val3)
Arguments:
	[in]	val1 = float
	[in]	val2 = float
	[in]	val3 = float

Sets the stored value of this data object as a triple of floats.
The data object must have been created as a triple of floats for
this to succeed.'''
        pass

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

'''
        pass

    def setData2Short(self, val1, val2): 
        '''setData2Short(self, val1, val2)
Arguments:
	[in]	val1 = short
	[in]	val2 = short

Sets the stored value of this data object as a pair of short
integers. The data object must have been created as a pair of short
integers for this to succeed.'''
        pass

    def getData3Short(self, val1, val2, val3): 
        '''getData3Short(self, val1, val2, val3)
Arguments:
	[out]	val1 = short
	[out]	val2 = short
	[out]	val3 = short

Gets the stored value of this data object as a triple of short
integers. The data object must have been created as a pair of short
integers for this to succeed.'''
        pass

class MFnNurbsCurve:
    '''NURBS curve function set.'''
    def __init__(self):
        pass


    def getCVs(self, space, array): 
        '''getCVs(self, space, array)
Arguments:
	[out]	array = MPointArray
	[in]	space = MSpace.Space

Get the positions of the CVs of this curve. The returned group
can be accessed via the  MPointArray  class. Any
modifications to these CVs will not affect this curve.
 setCVs  should be called to modify the original curve.
 updateCurve  should be called to cause the curve to redraw
itself.'''
        pass

    def numSpans(self): 
        '''numSpans(self) -> int
Returns: Returns:
The number of spans for this curve.

Return the number of spans for this curve. If the number of
spans cannot be determined then 0 is returned.'''
        pass

    def getParamAtPoint(self, atThisPoint, tolerance, space, param): 
        '''getParamAtPoint(self, atThisPoint, tolerance, space, param)
Arguments:
	[in]	atThisPoint = MPoint
	[out]	param = double
	[in]	tolerance = double
	[in]	space = MSpace.Space

This method retrieves the parameter value corresponding to the
given point on the curve.'''
        pass

    def setKnots(self, array, startIndex, endIndex): 
        '''setKnots(self, array, startIndex, endIndex)
Arguments:
	[in]	array = MDoubleArray
	[in]	startIndex = int
	[in]	endIndex = int

This method is used to set the values of a contiguous group of
knots of the curve. The range of knots to set is specified using
the start and end index. The knots of index startIndex to endIndex
inclusive will be set using the value in the double array.'''
        pass

    def isPlanar(self, planeNormal): 
        '''isPlanar(self, planeNormal) -> bool
Returns: Returns:
Status code

Arguments:
	[in]	planeNormal = MVector

This method determines if this curve is a planar curve. If
planeNormal is non-NULL then the normal to the plane containing
this curve is returned in this location.'''
        pass

    def cv(self, index): 
        '''cv(self, index) -> MObject
Returns: Returns:
A handle to the CVs requested

Arguments:
	[out]	index = int

Get a direct access handle to the CV at the specified index. The
CV iterator class  MItCurveCV  must be
used to access the returned CV.'''
        pass

    def removeKnot(self, atThisParam, removeAll): 
        '''removeKnot(self, atThisParam, removeAll)
Arguments:
	[in]	atThisParam = double
	[in]	removeAll = bool

Remove knot(s) from this curve. If  removeAll  is
 true  then all of the knots except for the knot at the given
parameter value will be removed. If  removeAll  is
 false  then only the knot at the given parameter value will
be removed.'''
        pass

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

This method determines if the shape was created with
history.'''
        pass

    def form(self): 
        '''form(self) -> MFnNurbsCurve.Form
Returns: Returns:


MFnNurbsCurve::kOpen
MFnNurbsCurve::kClosed
MFnNurbsCurve::kPeriodic

This method returns the form of the curve. The curve can be
open, closed, or periodic.'''
        pass

    def kClosed(self):
        '''This is an enum of Form.
Description: Endpoints are coincident.
Value: 2'''
        pass

    def kOpen(self):
        '''This is an enum of Form.
Description: Ends are independent.
Value: 1'''
        pass

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

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

    def kPeriodic(self):
        '''This is an enum of Form.
Description: Ends overlap such that there is no break in tangency.
Value: 3'''
        pass

    class Form:
        '''Non-functional class.  Values for this enum:
        kClosed
        kOpen
        kInvalid
        kLast
        kPeriodic
'''
        def __init__(self):
            pass

    def area(self, tolerance): 
        '''area(self, tolerance) -> double
Returns: Returns:
Status code

Arguments:
	[in]	tolerance = double

This method returns the area bounded by this curve. The curve
must be closed and planar.'''
        pass

    def setCVs(self, array, space): 
        '''setCVs(self, array, space)
Arguments:
	[in]	array = MPointArray
	[in]	space = MSpace.Space

Set the CVs for this curve to the given points.'''
        pass

    def create(self, sources, parentOrOwner): 
        '''create(self, sources, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this curve is
returned
If parentOrOwner is a DAG object then the curve shape is
returned
The curve geometry is returned if parentOrOwner is of type
kNurbsCurveData

Arguments:
	[in]	sources = MObjectArray
	[in]	parentOrOwner = MObject

This method creates a single curve that represents all the
curves in the  MObjectArray . The method assumes
the curves in the sources are good for building a single curve:'''
        pass

    def updateCurve(self): 
        '''updateCurve(self)
This method signals that this curve has changed and needs to be
recalculated.'''
        pass

    def isPointOnCurve(self, point, tolerance, space): 
        '''isPointOnCurve(self, point, tolerance, space) -> bool
Returns: Returns:
true if the given point is on the curve, false
otherwise.

Arguments:
	[in]	point = MPoint
	[in]	tolerance = double
	[in]	space = MSpace.Space

Determines whether the given point is on this curve.'''
        pass

    def findParamFromLength(self, partLength): 
        '''findParamFromLength(self, partLength) -> double
Returns: Returns:
The parameter value corrisponding to the given length. If a
parameter cannot be found for the given length then the parameter
for the end point of the curve is returned.

Arguments:
	[in]	partLength = double

Given the length along the curve, find the parameter value that
corresponds to it. If the parameter value cannot be found for the
given length then ReturnStatus is set to kInvalidParameter and the
parameter for the end point of the curve is returned.'''
        pass

    def getPointAtParam(self, param, space, point): 
        '''getPointAtParam(self, param, space, point)
Arguments:
	[in]	param = double
	[out]	point = MPoint
	[in]	space = MSpace.Space

Returns the point in space that is at the given parameter value
of the curve. If the parameter value does not give a valid point on
the curve, then  MS::kInvalidParameter 
is returned.'''
        pass

    def setKnot(self, index, param): 
        '''setKnot(self, index, param)
Arguments:
	[in]	index = int
	[in]	param = double

Set the given knot's parameter value. Knot indices range from
 0  to  numKnots() 
- 1 .'''
        pass

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

'''
        pass

    def getCV(self, index, space, pt): 
        '''getCV(self, index, space, pt)
Arguments:
	[in]	index = int
	[out]	pt = MPoint
	[in]	space = MSpace.Space

Get the CV at the given index.'''
        pass

    def closestPoint(self, toThisPoint, paramAsStart, param, tolerance, space): 
        '''closestPoint(self, toThisPoint, paramAsStart, param, tolerance, space) -> MPoint
Returns: Returns:
The point on the curve closest to the given point.

Arguments:
	[in]	toThisPoint = MPoint
	[in]	paramAsStart = bool
	[in]	param = double
	[in]	tolerance = double
	[in]	space = MSpace.Space

This method determines the closest point on the curve to the
given point. Performance can be greatly increased by supplying a
starting parameter value that is reasonably close to the final
point.'''
        pass

    def isParamOnCurve(self, param): 
        '''isParamOnCurve(self, param) -> bool
Returns: Returns:


true The parameter is on this curve.
false Parameter is NOT on this curve.

Arguments:
	[in]	param = double

Determines whether the specified parameter value is within the
bounds of the knot vector of this curve'''
        pass

    def degree(self): 
        '''degree(self) -> int
Returns: Returns:
The degree of this curve.

Return the degree of this curve. If the degree cannot be
determined then 0 is returned.'''
        pass

    def normal(self, param, space): 
        '''normal(self, param, space) -> MVector
Returns: Returns:
The normal vector for the given parameter

Arguments:
	[in]	param = double
	[in]	space = MSpace.Space

This method returns the normal at the given parameter value on
the curve. For degree 1 curves the normal is the vector at right
angles to the curve that lies in the average plane of the curve.
For higher degrees the normal is defined by the local curvature at
param.'''
        pass

    def tangent(self, param, space): 
        '''tangent(self, param, space) -> MVector
Returns: Returns:
The tangent vector for the given parameter

Arguments:
	[in]	param = double
	[in]	space = MSpace.Space

This method returns the tangent at the given parameter value on
the curve. The resulting tangent vector is normalized.'''
        pass

    def knot(self, index): 
        '''knot(self, index) -> double
Returns: Returns:
The parameter value for the knot at index.

Arguments:
	[in]	index = int

Get the parameter value of the specified knot for this curve.
Knot indices range from  0  to  numKnots() 
- 1'''
        pass

    def getKnotDomain(self, start, end): 
        '''getKnotDomain(self, start, end)
Arguments:
	[out]	start = double
	[out]	end = double

Return the range corresponding to the maximum and minimum
parameter values for this curve.'''
        pass

    def numCVs(self): 
        '''numCVs(self) -> int
Returns: Returns:
The number of CVs for this curve.

Return the number of CVs for this curve. If the number of CVs
cannot be determined then 0 is returned.'''
        pass

    def setCV(self, index, pt, space): 
        '''setCV(self, index, pt, space)
Arguments:
	[in]	index = int
	[in]	pt = MPoint
	[in]	space = MSpace.Space

Set the CV at the given index to the given point. The method
 updateCurve  should be called to trigger changes in the
curve.'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this curve is
returned
If parentOrOwner is a DAG object then the curve shape is
returned
The curve geometry is returned if parentOrOwner is of type
kNurbsCurveData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject

This method creates a copy of a nurbs curve.'''
        pass

    def numKnots(self): 
        '''numKnots(self) -> int
Returns: Returns:
The number of knots for this curve.

Return the number of knots for this curve. If the number of
knots cannot be determined then 0 is returned.'''
        pass

    def reverse(self, constructionHistory): 
        '''reverse(self, constructionHistory)
Arguments:
	[in]	constructionHistory = bool

This method reverse the curve direction.'''
        pass

    def cvs(self, startIndex, endIndex): 
        '''cvs(self, startIndex, endIndex) -> MObject
Returns: Returns:
An MObject
providing direct-access to the specified CVs

Arguments:
	[in]	startIndex = int
	[in]	endIndex = int

This method is used to directly access a contiguous group of
CVs. The returned group can be accessed via the  MItCurveCV  class. Any
modifications to these CVs will affect this curve.
 updateCurve  should be called to cause the curve to redraw
itself.'''
        pass

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

'''
        pass

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

This method retrieves a copy of the knot array for this
curve.'''
        pass

    def length(self, tolerance): 
        '''length(self, tolerance) -> double
Returns: Returns:
Status code

Arguments:
	[in]	tolerance = double

Return the arc length of this curve or 0.0 if it cannot be
computed.'''
        pass

    def getDerivativesAtParm(self, param, space, pos, dU, dUU): 
        '''getDerivativesAtParm(self, param, space, pos, dU, dUU)
Arguments:
	[in]	param = double
	[out]	pos = MPoint
	[out]	dU = MVector
	[in]	space = MSpace.Space
	[out]	dUU = MVector

Evaluate the surface at the given parameter returning the
position, first derivative and optionally the seecond derivative.
Derivatives are not normalized.'''
        pass

    def makeMultipleEndKnots(self): 
        '''makeMultipleEndKnots(self)
This method gives end knots full multiplicity. This ensures the
end points of the curve interpolate the first and last CVs. It can
also be used to convert a periodic curve to a closed curve.'''
        pass

    def distanceToPoint(self, pt, space): 
        '''distanceToPoint(self, pt, space) -> double
Returns: Returns:
Status code

Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space

This method determines the distance from the given point to
closest point on the curve.'''
        pass

    def createWithEditPoints(self, editPoints, degree, form, create2D, createRational, uniformParam, parentOrOwner): 
        '''createWithEditPoints(self, editPoints, degree, form, create2D, createRational, uniformParam, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this curve is
returned
If parentOrOwner is a DAG object then the curve shape is
returned
The curve geometry is returned if parentOrOwner is of type
kNurbsCurveData

Arguments:
	[in]	editPoints = MPointArray
	[in]	degree = int
	[in]	form = MFnNurbsCurve.Form
	[in]	create2D = bool
	[in]	createRational = bool
	[in]	uniformParam = bool
	[in]	parentOrOwner = MObject

This method creates a nurbs curve from the given edit points and
sets this function set to operate on the new curve.'''
        pass

class MFnNurbsCurveData:
    '''Nurbs Curve function set for dependency node data.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: Returns:
The new MObject

Create a new  MObject , attach it to this instance and
initialize it with a data block capable of holding a Nurbs
Curve.'''
        pass

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

'''
        pass

class MFnNurbsSurface:
    '''NURBS surface function set.'''
    def __init__(self):
        pass


    def trim(self, locatorU, locatorV, constructionHistory): 
        '''trim(self, locatorU, locatorV, constructionHistory)
Arguments:
	[in]	locatorU = MDoubleArray
	[in]	locatorV = MDoubleArray
	[in]	constructionHistory = bool

Trim this surface to its curves on surface. Regions which are
kept are specified by passing in two arrays of u,v parameters.'''
        pass

    def getAssignedUVs(self, uvCounts, uvIds): 
        '''getAssignedUVs(self, uvCounts, uvIds)
Arguments:
	[out]	uvCounts = MIntArray
	[out]	uvIds = MIntArray

Get assigned UVs. This method finds all texture coordinates for
the surface that have been mapped, and returns them in the same
format as assignUVs. The setUV/setUVs method is used to create the
texture coordinate table for the surface and this method is used to
map those values to each patch on a per-corner basis.'''
        pass

    def getCVs(self, space, array): 
        '''getCVs(self, space, array)
Arguments:
	[out]	array = MPointArray
	[in]	space = MSpace.Space

Get the positions of the CVs on this surface. The returned group
can be accessed via the  MPointArray  class.  numCVsInU() 
*  numCVsInV() 
points will be returned. Converting from uIndex, vIndex is done by
"index = numCVsInV() * uIndex + vIndex".'''
        pass

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

Get the knots along the V direction for this surface.'''
        pass

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

Get the knots along the U direction for this surface.'''
        pass

    def numBoundaries(self, region): 
        '''numBoundaries(self, region) -> int
Returns: Returns:
The number of boundaries for the specified region

Arguments:
	[in]	region = int

Returns the number of boudaries for the specified region. The
surface must be a trimmed surface.'''
        pass

    def setKnotsInV(self, array, startIndex, endIndex): 
        '''setKnotsInV(self, array, startIndex, endIndex)
Arguments:
	[in]	array = MDoubleArray
	[in]	startIndex = int
	[in]	endIndex = int

Set the specified V knot values for this surface.'''
        pass

    def setKnotsInU(self, array, startIndex, endIndex): 
        '''setKnotsInU(self, array, startIndex, endIndex)
Arguments:
	[in]	array = MDoubleArray
	[in]	startIndex = int
	[in]	endIndex = int

Set the specified U knot values for this surface.'''
        pass

    def getParamAtPoint(self, atThisPoint, ignoreTrimBoundaries, space, tolerance, paramU, paramV): 
        '''getParamAtPoint(self, atThisPoint, ignoreTrimBoundaries, space, tolerance, paramU, paramV)
Arguments:
	[in]	atThisPoint = MPoint
	[out]	paramU = double
	[out]	paramV = double
	[in]	ignoreTrimBoundaries = bool
	[in]	space = MSpace.Space
	[in]	tolerance = double

Get the parameter value corresponding to the given point on the
surface (or underlying surface).'''
        pass

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

Evaluate the surface to determine if it contains any folds or
creases. The entire surface including trimmed regions is examined.
This function will only check for folds on bispan boundaries and
thus will not catch all cases.'''
        pass

    def degreeV(self): 
        '''degreeV(self) -> int
Returns: Returns:
The degree in V

Returns the degree of the surface in V (1 - 3).'''
        pass

    def degreeU(self): 
        '''degreeU(self) -> int
Returns: Returns:
The degree in U

Returns the degree of the surface in U (1 - 3).'''
        pass

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

This method determines if this surface is a trimmed surface.'''
        pass

    def numSpansInU(self): 
        '''numSpansInU(self) -> int
Returns: Returns:
The number of spans in U

Returns the number of spans in the u direction.'''
        pass

    def getTangents(self, paramInU, paramInV, space, vectorInU, vectorInV): 
        '''getTangents(self, paramInU, paramInV, space, vectorInU, vectorInV)
Arguments:
	[in]	paramInU = double
	[in]	paramInV = double
	[out]	vectorInU = MVector
	[out]	vectorInV = MVector
	[in]	space = MSpace.Space

Retrieve the tangents in the U and V directions at the given
parameter value on the surface. The returned tangent vectors are
normalized.'''
        pass

    def numSpansInV(self): 
        '''numSpansInV(self) -> int
Returns: Returns:
The number of spans in V

Returns the number of spans in the v direction.'''
        pass

    def formInV(self): 
        '''formInV(self) -> MFnNurbsSurface.Form
Returns: Returns:
The form of this surface in V

Return the form of this surface in V. Form can be kOpen,
kClosed, kPeriodic, or kUnknownForm.'''
        pass

    def numCVsInU(self): 
        '''numCVsInU(self) -> int
Returns: Returns:
The number of CVs in U

Returns the number of CVs in the U direction (degree +
spans).'''
        pass

    def numCVsInV(self): 
        '''numCVsInV(self) -> int
Returns: Returns:
The number of CVs in V

Returns the number of CVs in the V direction (degree +
spans).'''
        pass

    def formInU(self): 
        '''formInU(self) -> MFnNurbsSurface.Form
Returns: Returns:
The form of this surface in U

Return the form of this surface in U. Form can be kOpen,
kClosed, kPeriodic, or kUnknownForm.'''
        pass

    def cv(self, indexU, indexV): 
        '''cv(self, indexU, indexV) -> MObject
Returns: Returns:
The cv component

Arguments:
	[in]	indexU = int
	[in]	indexV = int

Returns a component for the specified CV.'''
        pass

    def numUVs(self): 
        '''numUVs(self) -> int
Returns: Returns:
The number of texture coordinates

Returns the number of texture (uv) coordinates for this surface.
The uv's are stored in a list which is referenced by patches
requiring textures on a per-patch per-patchCorner basis. This
method returns the number of elements in this list.'''
        pass

    def setKnotInV(self, index, param): 
        '''setKnotInV(self, index, param)
Arguments:
	[in]	index = int
	[in]	param = double

Set the value of the given existing knot at the specified V
index. Knots are indexed from 0 to numKnots-1. Note that this
routine does not insert a new knot, it simply changes the value of
a knot that already exists.'''
        pass

    def projectCurve(self, curve, direction, constructionHistory): 
        '''projectCurve(self, curve, direction, constructionHistory)
Arguments:
	[in]	curve = MDagPath
	[in]	direction = MVector
	[in]	constructionHistory = bool

Project the given curve onto this surface creating a curve on
surface. Projection will be done using the surface normals unless a
direction vector to project along is given.'''
        pass

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

This method determines if the shape was created with
history.'''
        pass

    def numPatchesInV(self): 
        '''numPatchesInV(self) -> int
Returns: Returns:
The number of non-zero patches along v, in this surface.

Returns the number of non-zero patches along v, in this
surface.'''
        pass

    def setKnotInU(self, index, param): 
        '''setKnotInU(self, index, param)
Arguments:
	[in]	index = int
	[out]	param = double

Set the value of the given existing knot at the specified U
index. Knots are indexed from 0 to numKnots-1. Note that this
routine does not insert a new knot, it simply changes the value of
a knot that already exists.'''
        pass

    def kClosed(self):
        '''This is an enum of Form.
Description: Edges are coincident.
Value: 2'''
        pass

    def kOpen(self):
        '''This is an enum of Form.
Description: Edges are independent.
Value: 1'''
        pass

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

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

    def kPeriodic(self):
        '''This is an enum of Form.
Description: Edges overlap such that there is no break in tangency.
Value: 3'''
        pass

    class Form:
        '''Non-functional class.  Values for this enum:
        kClosed
        kOpen
        kInvalid
        kLast
        kPeriodic
'''
        def __init__(self):
            pass

    def area(self, space, tolerance): 
        '''area(self, space, tolerance) -> double
Returns: Returns:
The area of this surface

Arguments:
	[in]	space = MSpace.Space
	[in]	tolerance = double

Calculates the surface area of this nurbs surface in world or
local space. A value of 0.0 will be returned if the area cannot be
determined successfully.'''
        pass

    def setCVs(self, array, space): 
        '''setCVs(self, array, space)
Arguments:
	[in]	array = MPointArray
	[in]	space = MSpace.Space

Set the CVs for this surface to the given points.  numCVsInU() 
*  numCVsInV() 
points must be provided. Converting from uIndex, vIndex is done by
"index = numCVsInV() * uIndex + vIndex".'''
        pass

    def getPointAtParam(self, paramU, paramV, space, point): 
        '''getPointAtParam(self, paramU, paramV, space, point)
Arguments:
	[in]	paramU = double
	[in]	paramV = double
	[out]	point = MPoint
	[in]	space = MSpace.Space

Finds the point corresponding to the given parameter value on
the surface.'''
        pass

    def create(self, controlVertices, uKnotSequences, vKnotSequences, degreeInU, degreeInV, formU, formV, createRational, parentOrOwner): 
        '''create(self, controlVertices, uKnotSequences, vKnotSequences, degreeInU, degreeInV, formU, formV, createRational, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kNurbsSurfaceData

Arguments:
	[in]	controlVertices = MPointArray
	[in]	uKnotSequences = MDoubleArray
	[in]	vKnotSequences = MDoubleArray
	[in]	degreeInU = int
	[in]	degreeInV = int
	[in]	formU = MFnNurbsSurface.Form
	[in]	formV = MFnNurbsSurface.Form
	[in]	createRational = bool
	[in]	parentOrOwner = MObject

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

    def knotInU(self, index): 
        '''knotInU(self, index) -> double
Returns: Returns:
The knot value

Arguments:
	[in]	index = int

Retrieve the given knot value from this surface at the specified
U index. Knots are indexed from 0 to numKnots-1.'''
        pass

    def isPointInTrimmedRegion(self, u, v): 
        '''isPointInTrimmedRegion(self, u, v) -> bool
Returns: Returns:
Boolean value: true if the point on surface is within a
trimmed away region, false otherwise.

Arguments:
	[in]	u = double
	[in]	v = double

Returns true if the given point is in a trimmed away region of a
trimmed surface. A trimmed away region is the part of the surface
that is cut away as a result of a trim operation.'''
        pass

    def kClosedSegment(self):
        '''This is an enum of BoundaryType.
Description: Closed curve on a face.
Value: 4'''
        pass

    def kSegment(self):
        '''This is an enum of BoundaryType.
Description: Curve on a face.
Value: 3'''
        pass

    def kOuter(self):
        '''This is an enum of BoundaryType.
Description: Outer boundary, counter clockwise.
Value: 1'''
        pass

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

    def kInner(self):
        '''This is an enum of BoundaryType.
Description: Inner boundary, clockwise.
Value: 2'''
        pass

    class BoundaryType:
        '''Non-functional class.  Values for this enum:
        kClosedSegment
        kSegment
        kOuter
        kInvalidBoundary
        kInner
'''
        def __init__(self):
            pass

    def edge(self, region, boundary, edge, paramEdge): 
        '''edge(self, region, boundary, edge, paramEdge) -> MObjectArray
Returns: Returns:
A curve for the specified edge

Arguments:
	[in]	region = int
	[in]	boundary = int
	[in]	edge = int
	[in]	paramEdge = bool

Return the specified edge of a trim boundary.'''
        pass

    def removeOneKnotInU(self, atThisParam): 
        '''removeOneKnotInU(self, atThisParam)
Arguments:
	[in]	atThisParam = double

Remove one U knot at the specified parameter value from this
surface.'''
        pass

    def removeOneKnotInV(self, atThisParam): 
        '''removeOneKnotInV(self, atThisParam)
Arguments:
	[in]	atThisParam = double

Remove one V knot at the specified parameter value from this
surface.'''
        pass

    def intersect(self, rayStartingPoint, alongThisDirection, tolerance, space, calculateDistance, calculateExactHit, uArray, vArray, points, distances, wasExactHit): 
        '''intersect(self, rayStartingPoint, alongThisDirection, tolerance, space, calculateDistance, calculateExactHit, uArray, vArray, points, distances, wasExactHit) -> bool
Returns: Returns:
Boolean value: true if an intersection point has been
found, false otherwise.

Arguments:
	[in]	rayStartingPoint = MPoint
	[in]	alongThisDirection = MVector
	[out]	uArray = MDoubleArray
	[out]	vArray = MDoubleArray
	[out]	points = MPointArray
	[in]	tolerance = double
	[in]	space = MSpace.Space
	[in]	calculateDistance = bool
	[out]	distances = MDoubleArray
	[in]	calculateExactHit = bool
	[out]	wasExactHit = bool

This function determines all the points of intersection of this
spline surface with a ray (a vector at a point).'''
        pass

    def isFlipNorm(self, region): 
        '''isFlipNorm(self, region) -> bool

Arguments:
	[in]	region = int

Determines whether the normal for the specified region is
flipped. This method is only valid for trimmed surfaces.'''
        pass

    def removeKnotInU(self, atThisParam, removeAll): 
        '''removeKnotInU(self, atThisParam, removeAll)
Arguments:
	[in]	atThisParam = double
	[in]	removeAll = bool

Remove the U knot(s) at the specified parameter value from this
surface. If there are multiple knots at this parameter then
removeAll is used to specify how to do the removal.'''
        pass

    def removeKnotInV(self, atThisParam, removeAll): 
        '''removeKnotInV(self, atThisParam, removeAll)
Arguments:
	[in]	atThisParam = double
	[in]	removeAll = bool

Remove the V knot(s) at the specified parameter value from this
surface. If there are multiple knots at this parameter then
removeAll is used to specify how to do the removal.'''
        pass

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

'''
        pass

    def numNonZeroSpansInV(self): 
        '''numNonZeroSpansInV(self) -> int
Returns: Returns:
The number of non-empty (non-zero, visual) spans in V

Returns the number of non-zero spans in the V direction. This
value will be equivalent to the value returned by  numSpansInV() 
if all of the internal (non-end) knots are of multiplicity 1. If
some of the internal knots have higher multiplicity, this value
will be lower than that returned by  numSpansInV() .
You can use the number of non-zero spans to count the number of
 visual  spans on the surface in the V direction, since the
empty (zero) spans do not appear as a separate span/patch in the
display.'''
        pass

    def getCV(self, indexU, indexV, space, pnt): 
        '''getCV(self, indexU, indexV, space, pnt)
Arguments:
	[in]	indexU = int
	[in]	indexV = int
	[out]	pnt = MPoint
	[in]	space = MSpace.Space

Get the location of the specified CV.'''
        pass

    def closestPoint(self, toThisPoint, paramAsStart, paramU, paramV, ignoreTrimBoundaries, tolerance, space): 
        '''closestPoint(self, toThisPoint, paramAsStart, paramU, paramV, ignoreTrimBoundaries, tolerance, space) -> MPoint

Arguments:
	[in]	toThisPoint = MPoint
	[in]	paramAsStart = bool
	[in]	paramU = double
	[in]	paramV = double
	[in]	ignoreTrimBoundaries = bool
	[in]	tolerance = double
	[in]	space = MSpace.Space

Return the closest point on this surface to the given point.'''
        pass

    def isPointOnSurface(self, point, tolerance, space): 
        '''isPointOnSurface(self, point, tolerance, space) -> bool
Returns: Returns:
Boolean value: true if the given point is on this
surface, false otherwise.

Arguments:
	[in]	point = MPoint
	[in]	tolerance = double
	[in]	space = MSpace.Space

Check if the given point is on this surface.'''
        pass

    def numPatchesInU(self): 
        '''numPatchesInU(self) -> int
Returns: Returns:
The number of non-zero patches along u, in this surface.

Returns the number of non-zero patches along u, in this
surface.'''
        pass

    def boundaryType(self, region, boundary): 
        '''boundaryType(self, region, boundary) -> MFnNurbsSurface.BoundaryType
Returns: Returns:
The boundary type:

kInner an inner boundary, clockwise
kOuter an outer boundary, counter clockwise
kSegment a boundary segment (a curve on face)
kClosedSegment a closed boundary segment (a closed curve
on face)
kInvalidBoundary an invalid boundary type

Arguments:
	[in]	region = int
	[in]	boundary = int

Returns the type of the specified boundary. The surface must be
a trimmed surface.'''
        pass

    def normal(self, paramInU, paramInV, space): 
        '''normal(self, paramInU, paramInV, space) -> MVector
Returns: Returns:
The normal vector

Arguments:
	[in]	paramInU = double
	[in]	paramInV = double
	[in]	space = MSpace.Space

Retrieve the normal at the given parameter value on the
surface.'''
        pass

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


true Uniform knot spacing
false Non-uniform knot spacing

Determine if the knot spacing is uniform.'''
        pass

    def isKnotU(self, param): 
        '''isKnotU(self, param) -> bool
Returns: Returns:
Boolean value: true if the parameter value is a knot
value, false otherwise.

Arguments:
	[in]	param = double

Check if the specified parameter value is a knot value.'''
        pass

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

Returns the number of trimmed regions for this surface or 0 if
the surface is not a trimmed surface.'''
        pass

    def isKnotV(self, param): 
        '''isKnotV(self, param) -> bool
Returns: Returns:
Boolean value: true if the parameter value is a knot
value, false otherwise.

Arguments:
	[in]	param = double

Check if the specified parameter value is a knot value.'''
        pass

    def getPatchUVid(self, patchId, cornerIndex, uvId): 
        '''getPatchUVid(self, patchId, cornerIndex, uvId)
Arguments:
	[in]	patchId = int
	[in]	cornerIndex = int
	[out]	uvId = int

Get the id of the specified texture coordinate for a corner in a
patch.'''
        pass

    def numEdges(self, region, boundary): 
        '''numEdges(self, region, boundary) -> int
Returns: Returns:
The number of edges for the specified boundary

Arguments:
	[in]	region = int
	[in]	boundary = int

Return the number of edges for the specified trim boundary.'''
        pass

    def isParamOnSurface(self, paramU, paramV): 
        '''isParamOnSurface(self, paramU, paramV) -> bool
Returns: Returns:
Boolean value: true if the parameter value on this
surface, false otherwise.

Arguments:
	[in]	paramU = double
	[in]	paramV = double

Check if the specified parameter is on this surface.'''
        pass

    def getKnotDomain(self, startU, endU, startV, endV): 
        '''getKnotDomain(self, startU, endU, startV, endV)
Arguments:
	[out]	startU = double
	[out]	endU = double
	[out]	startV = double
	[out]	endV = double

Returns the maximum and minimum U and V paramter values for this
surface.'''
        pass

    def numPatches(self): 
        '''numPatches(self) -> int
Returns: Returns:
The number of non-zero patches in this surface.

Returns the number of non-zero patches in this surface.'''
        pass

    def getTrimBoundaries(self, region, paramEdge, result): 
        '''getTrimBoundaries(self, region, paramEdge, result)
Arguments:
	[out]	result = MTrimBoundaryArray
	[in]	region = int
	[in]	paramEdge = bool

Returns all trim boundaries of a region on this surface.'''
        pass

    def setCV(self, indexU, indexV, pt, space): 
        '''setCV(self, indexU, indexV, pt, space)
Arguments:
	[in]	indexU = int
	[in]	indexV = int
	[in]	pt = MPoint
	[in]	space = MSpace.Space

Set the location of the specified CV.'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kNurbsSurfaceData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject

This method creates a copy of a nurbs surface.'''
        pass

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

Returns an  MObject 
if the class has been constructed with an  MFn::kNurbsSurfaceData  entity, otherwise
 MObject::kNullObj  is
returned.'''
        pass

    def setUVs(self, uArray, vArray): 
        '''setUVs(self, uArray, vArray)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray

Sets all of the texture coordinates (uvs) for this surface. The
uv arrays must be of equal size and must be at least of length
 numUVs() .
If the arrays are larger than  numUVs() 
then the uv list for this surface will be grown to accommodate the
new uv values.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)
This method signals that this surface has changed and needs to
be recalculated.'''
        pass

    def getUV(self, uvId, u, v): 
        '''getUV(self, uvId, u, v)
Arguments:
	[in]	uvId = int
	[out]	u = float
	[out]	v = float

Get the value of the specified texture coordinate from this
surface's uv list. The uvId is the element in the uv list that will
be retrieved.'''
        pass

    def getPatchUV(self, patchId, cornerIndex, u, v): 
        '''getPatchUV(self, patchId, cornerIndex, u, v)
Arguments:
	[in]	patchId = int
	[in]	cornerIndex = int
	[out]	u = float
	[out]	v = float

Get the value of the specified texture coordinate for a patch
corner in a patch. Since texture coordinates (uv's) are stored
per-patch per-corner you must specify both the patch and the corner
that the u and v values are mapped to.'''
        pass

    def cvsInV(self, startIndex, endIndex, rowIndex): 
        '''cvsInV(self, startIndex, endIndex, rowIndex) -> MObject
Returns: Returns:
The component for the CVs

Arguments:
	[in]	startIndex = int
	[in]	endIndex = int
	[in]	rowIndex = int

Returns a component for the specified CVs on the given V
direction.'''
        pass

    def cvsInU(self, startIndex, endIndex, rowIndex): 
        '''cvsInU(self, startIndex, endIndex, rowIndex) -> MObject
Returns: Returns:
The component for the CVs on the given U direction.

Arguments:
	[in]	startIndex = int
	[in]	endIndex = int
	[in]	rowIndex = int

Returns a component for the specified CVs.'''
        pass

    def getUVs(self, uArray, vArray): 
        '''getUVs(self, uArray, vArray)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray

This method copies the texture coordinate list for this surface
into the given uv arrays.'''
        pass

    def setUV(self, uvId, u, v): 
        '''setUV(self, uvId, u, v)
Arguments:
	[in]	uvId = int
	[in]	u = float
	[in]	v = float

Sets the specified texture coordinate. The uvId is the element
in the uv list that will be set. If the uvId is greater than or
equal to  numUVs() 
then the uv list will be grown to accommodate the specified uv.'''
        pass

    def tesselate(self, parms, parentOrOwner): 
        '''tesselate(self, parms, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kMeshData

Arguments:
	[in]	parms = MTesselationParams
	[in]	parentOrOwner = MObject

Performs tesselation on this surface and create a new mesh in
the DAG. The type of tesselation can be controlled by providing the
tesselation parameters (see  MTesselationParams ).'''
        pass

    def getPatchUVs(self, patchId, uArray, vArray): 
        '''getPatchUVs(self, patchId, uArray, vArray)
Arguments:
	[in]	patchId = int
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray

Get the values of the texture coordinate on a specified patch.
Since texture coordinates (uvs) are stored per-patch per-corner,
the u and v values mapped to all corners of the specified patch are
returned.'''
        pass

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

'''
        pass

    def knotInV(self, index): 
        '''knotInV(self, index) -> double
Returns: Returns:
The knot value

Arguments:
	[in]	index = int

Retrieve the given knot value from this surface at the specified
V index. Knots are indexed from 0 to numKnots-1.'''
        pass

    def assignUV(self, patchId, cornerIndex, uvId): 
        '''assignUV(self, patchId, cornerIndex, uvId)
Arguments:
	[in]	patchId = int
	[in]	cornerIndex = int
	[in]	uvId = int

Maps a texture coordinate to a the specified corner of a
patch.'''
        pass

    def getDerivativesAtParm(self, paramInU, paramInV, space, pos, dU, dV, dUU, dVV, dUV): 
        '''getDerivativesAtParm(self, paramInU, paramInV, space, pos, dU, dV, dUU, dVV, dUV)
Arguments:
	[in]	paramInU = double
	[in]	paramInV = double
	[out]	pos = MPoint
	[out]	dU = MVector
	[out]	dV = MVector
	[in]	space = MSpace.Space
	[out]	dUU = MVector
	[out]	dVV = MVector
	[out]	dUV = MVector

Evaluate the surface at the given (u,v) coordinate returning
position, first derivatives and optionally second derivative
information. The returned derivative vectors are not normalized. If
either dUU, dVV, or dUV is set to NULL, the second derivatives will
not be computed and execution time wil be faster.'''
        pass

    def numNonZeroSpansInU(self): 
        '''numNonZeroSpansInU(self) -> int
Returns: Returns:
The number of non-empty (non-zero, visual) spans in U

Returns the number of non-zero spans in the U direction. This
value will be equivalent to the value returned by  numSpansInU() 
if all of the internal (non-end) knots are of multiplicity 1. If
some of the internal knots have higher multiplicity, this value
will be lower than that returned by  numSpansInU() .
You can use the number of non-zero spans to count the number of
 visual  spans on the surface in the U direction, since the
empty (zero) spans do not appear as a separate span/patch in the
display.'''
        pass

    def assignUVs(self, uvCounts, uvIds): 
        '''assignUVs(self, uvCounts, uvIds)
Arguments:
	[in]	uvCounts = MIntArray
	[in]	uvIds = MIntArray

This method maps all texture coordinates for the surface. The
setUV/setUVs method is used to create the texture coordinate table
for the surface. After the table is created, this method is used to
map those values to each patch on a per-corner basis. The
setUV/setUVs method should be called before the assignUVs
method.'''
        pass

    def distanceToPoint(self, pt, space): 
        '''distanceToPoint(self, pt, space) -> double
Returns: Returns:
The distance to the given point from this surface

Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space

Returns the distance from the given point to the closest point
on the surface.'''
        pass

    def numKnotsInV(self): 
        '''numKnotsInV(self) -> int
Returns: Returns:
The number of knots in V

Returns the number of knots in V including multiple end knots
(spans + 2 * degree - 1).'''
        pass

    def numKnotsInU(self): 
        '''numKnotsInU(self) -> int
Returns: Returns:
The number of knots in U

Returns the number of knots in U including multiple end knots
(spans + 2 * degree - 1).'''
        pass

    def trimWithBoundaries(self, mBoundaries, flipNormal, e_tol, pe_tol): 
        '''trimWithBoundaries(self, mBoundaries, flipNormal, e_tol, pe_tol)
Arguments:
	[in]	mBoundaries = MTrimBoundaryArray
	[in]	flipNormal = bool
	[in]	e_tol = double
	[in]	pe_tol = double

This function trims this surface with given trim boundaries.'''
        pass

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


true Bezier surface
false B-spline surface

Determine if the knot spacing gives us Bezier surface.'''
        pass

    def clearUVs(self): 
        '''clearUVs(self)
This method clears out all texture coordinates for the
nurbsSurface, and leaves behind an empty UVset.'''
        pass

class MFnNurbsSurfaceData:
    '''Nurbs Surface function set for dependency node data.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: Returns:
The new MObject

Create a new  MObject , attach it to this instance and
initialize it with a data block capable of holding a Nurbs
Surface.'''
        pass

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

'''
        pass

class MFnPartition:
    '''Function set for partitions of objects.'''
    def __init__(self):
        pass


    def addMember(self, set): 
        '''addMember(self, set)
Arguments:
	[in]	set = MObject

Add a set to this partition. To be added to a partition, a set
must be mutually exclusive with all of the other sets in the
partition. If there are any conflicting elements, then the add will
fail.'''
        pass

    def create(self, isRenderPartition): 
        '''create(self, isRenderPartition) -> MObject
Returns: Returns:
A handle for the new partition object

Arguments:
	[in]	isRenderPartition = bool

Creates a new partition dependency node and puts it in the
dependency graph.'''
        pass

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

'''
        pass

    def removeMember(self, set): 
        '''removeMember(self, set)
Arguments:
	[in]	set = MObject

Remove a set from this partition.'''
        pass

    def isRenderPartition(self): 
        '''isRenderPartition(self) -> bool
Returns: Returns:
A boolean value indicating whether the object is a member

Returns true if this partition is a render partition.'''
        pass

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

'''
        pass

class MFnPhongEShader:
    '''Manage phongE shaders.'''
    def __init__(self):
        pass


    def highlightSize(self): 
        '''highlightSize(self) -> float
Returns: Returns:
The value of the "highlightSize" attribute of the shader
node.

Retrieves the value of the "highlightSize" attribute of a shader
node. This attribute represents the surface color of the
shader.'''
        pass

    def setWhiteness(self, whiteness): 
        '''setWhiteness(self, whiteness)
Arguments:
	[in]	whiteness = MColor

Sets the value of the "whiteness" attribute of a shader
node.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	UIvisible = bool

Creates a new layered shader dependency graph node and adds it
to the dependency graph. If the UIvisible parameter is true, the
new node will be connected to the shader classification node (which
allows the UI to recognize the node as a shader). If UIvisible is
false, the node will be created in isolation.'''
        pass

    def whiteness(self): 
        '''whiteness(self) -> MColor
Returns: Returns:
The value of the "whiteness" attribute of the shader node.

Retrieves the value of the "whiteness" attribute of a shader
node. This attribute represents the surface transparency of the
shader.'''
        pass

    def roughness(self): 
        '''roughness(self) -> float
Returns: Returns:
The value of the "roughness" attribute of the shader node.

Retrieves the value of the "roughness" attribute of a shader
node.'''
        pass

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

'''
        pass

    def setHighlightSize(self, highlight_size): 
        '''setHighlightSize(self, highlight_size)
Arguments:
	[in]	highlight_size = float

Sets the value of the "highlightSize" attribute of a shader
node.'''
        pass

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

'''
        pass

    def setRoughness(self, roughness): 
        '''setRoughness(self, roughness)
Arguments:
	[in]	roughness = float

Sets the value of the "roughness" attribute of a shader
node.'''
        pass

class MFnPhongShader:
    '''Manage Phong Shaders.'''
    def __init__(self):
        pass


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

'''
        pass

    def cosPower(self): 
        '''cosPower(self) -> float
Returns: Returns:
The value of the "cosPower" attribute of the shader node.

Retrieves the value of the "cosPower" attribute of a phong
shader node. This attribute determines the size of specular
highlights produced by the shader.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	UIvisible = bool

Creates a new phong shader dependency graph node and adds it to
the dependency graph. If the UIvisible parameter is true, the new
node will be connected to the shader classification node (which
allows the UI to recognize the node as a shader). If UIvisible is
false, the node will be created in isolation.'''
        pass

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

'''
        pass

    def setCosPower(self, cos_power): 
        '''setCosPower(self, cos_power)
Arguments:
	[in]	cos_power = float

Sets the value of the "cosPower" attribute of a shader node.'''
        pass

class MFnPlugin:
    '''Register and deregister plug-in services with Maya.'''
    def __init__(self):
        pass


    def deregisterDevice(self, deviceName): 
        '''deregisterDevice(self, deviceName)
Arguments:
	[in]	deviceName = MString

Deregister the given user defined input device from Maya.'''
        pass

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

    def registerTransform(self, typeName, typeId, creatorFunction, initFunction, xformCreatorFunction, xformId, classification): 
        '''registerTransform(self, typeName, typeId, creatorFunction, initFunction, xformCreatorFunction, xformId, classification)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	initFunction = MFnPlugin.MInitializeFunction
	[in]	xformCreatorFunction = MFnPlugin.MCreateXformMatrixFunction
	[in]	xformId = MTypeId
	[in]	classification = MString

Registers the given user defined transform node with Maya. Once
registered, the transform can be used from MEL in a manner
identical to built-in Maya nodes.'''
        pass

    def deregisterControlCommand(self, commandName): 
        '''deregisterControlCommand(self, commandName)
Arguments:
	[in]	commandName = MString

Deregister the user defined control command from Maya. Once
deregistered the command can no longer be invoked from MEL.'''
        pass

    def registerFileTranslator(self, translatorName, pixmapName, creatorFunction, optionsScriptName, defaultOptionsString, requiresFullMel): 
        '''registerFileTranslator(self, translatorName, pixmapName, creatorFunction, optionsScriptName, defaultOptionsString, requiresFullMel)
Arguments:
	[in]	translatorName = MString
	[in]	pixmapName = char
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	optionsScriptName = char
	[in]	defaultOptionsString = char
	[in]	requiresFullMel = bool

Register a new file translator with Maya.'''
        pass

    def addMenuItem(self, menuItemName, parentName, commandName, commandParams, needOptionBox, optBoxFunction): 
        '''addMenuItem(self, menuItemName, parentName, commandName, commandParams, needOptionBox, optBoxFunction) -> MStringArray
Returns: Returns:
MStringArray returns the
names of the new menuItems created. In case the method fails, and
MStringArray has items in it,
removeMenuItem()
should be called on it to remove the unused UI references.

Arguments:
	[in]	menuItemName = MString
	[in]	parentName = MString
	[in]	commandName = MString
	[in]	commandParams = MString
	[in]	needOptionBox = bool
	[in]	optBoxFunction = MString

The function adds the menuItem to the specified parent, and
associates a command with it. Additionally, an option box can be
created and a MEL function/command can be added to it. The function
returns the names of the new menuItem and the optionBox
created.'''
        pass

    def registerDevice(self, deviceName, creatorFunction): 
        '''registerDevice(self, deviceName, creatorFunction)
Arguments:
	[in]	deviceName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction

Register a new input device with Maya. Once registered, the new
input device can be connected to Maya actions using the
 assignInputDevice  command in MEL in a manner identical to
built-in Maya devices.  In Maya 1.0, only Midi input devices are
supported and the creatorFunction must return a pointer to a
 MPxMidiInputDevice  instance. This
interface will be generalized in a future release.'''
        pass

    def registerConstraintCommand(self, commandName, creatorFunction): 
        '''registerConstraintCommand(self, commandName, creatorFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction

Register a new constraint command with Maya. Once registered,
the command can be invoked from MEL in a manner identical to
built-in Maya commands.'''
        pass

    def registerModelEditorCommand(self, commandName, creatorFunction, viewCreatorFunction): 
        '''registerModelEditorCommand(self, commandName, creatorFunction, viewCreatorFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	viewCreatorFunction = MFnPlugin.MCreatorFunction

Register a new model editor command with Maya. Once registered,
the command can be invoked from MEL in a manner identical to
built-in Maya commands.'''
        pass

    def deregisterContextCommand(self, commandName, toolCmdName): 
        '''deregisterContextCommand(self, commandName, toolCmdName)
Arguments:
	[in]	commandName = MString
	[in]	toolCmdName = MString

Deregister the given user defined context command and tool
command from Maya. Once deregistered the user defined tool can no
longer be used and the tool command can no longer be invoked from
MEL.'''
        pass

    def setVersion(self, newVersion): 
        '''setVersion(self, newVersion)
Arguments:
	[in]	newVersion = MString

Set the version name for this plug-in.'''
        pass

    def deregisterNode(self, typeId): 
        '''deregisterNode(self, typeId)
Arguments:
	[in]	typeId = MTypeId

Deregister the given user defined dependency node type Maya.
Once deregistered new instances of the user defined dependency node
can no longer be created. Additionally, any existing instances of
the node type will be changed to the special type  Unknown 
and will no longer evaluate in the dependency graph although they
will be saved correctly if the scene is written.'''
        pass

    def registerMaterialInfo(self, materialInfoName, fnPtr): 
        '''registerMaterialInfo(self, materialInfoName, fnPtr)
Arguments:
	[in]	materialInfoName = MString
	[in]	fnPtr = MMaterialInfoFactoryFnPtr

Registers a new material information type with Maya.'''
        pass

    def deregisterCommand(self, commandName): 
        '''deregisterCommand(self, commandName)
Arguments:
	[in]	commandName = MString

Deregister the user defined command from Maya. Once deregistered
the command can no longer be invoked from MEL.'''
        pass

    def registerIkSolver(self, ikSolverName, creatorFunction): 
        '''registerIkSolver(self, ikSolverName, creatorFunction)
Arguments:
	[in]	ikSolverName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction

Register a new ik-solver with Maya. NOTE: this method is
obsolete. Instead, register the IK solver as a node as described in
the example plug-in simpleSolverNode.cpp.'''
        pass

    def deregisterModelEditorCommand(self, commandName): 
        '''deregisterModelEditorCommand(self, commandName)
Arguments:
	[in]	commandName = MString

Deregister the user defined editor command from Maya. Once
deregistered the command can no longer be invoked from MEL.'''
        pass

    def matrixTypeIdFromXformId(self, xformTypeId): 
        '''matrixTypeIdFromXformId(self, xformTypeId) -> MTypeId
Returns: Returns:
MTypeId TypeId of
the corresponding transformation matrix, if found.

Arguments:
	[in]	xformTypeId = MTypeId

The function returns the  MTypeId  of the matrix
when the  MTypeId  of the
corresponding xform is given.'''
        pass

    def deregisterImageFile(self, imageFormatName): 
        '''deregisterImageFile(self, imageFormatName)
Arguments:
	[in]	imageFormatName = MString

Deregister the specified image file translator with Maya.'''
        pass

    def registerBakeEngine(self, bakeEngineGenName, fnPtr): 
        '''registerBakeEngine(self, bakeEngineGenName, fnPtr)
Arguments:
	[in]	bakeEngineGenName = MString
	[in]	fnPtr = MBakeEngineCreatorFnPtr

Registers a new bake engine type with Maya.'''
        pass

    def version(self): 
        '''version(self) -> MString
Returns: Returns:
An MString containing the version
string

Return the version string supplied in the  MFnPlugin 
constructor.'''
        pass

    def removeMenuItem(self, menuItemNames): 
        '''removeMenuItem(self, menuItemNames)
Arguments:
	[in]	menuItemNames = MStringArray

The function removes the menuItem and the corresponding option
box, if exists, from the UI.'''
        pass

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

Return the type of this function set.'''
        pass

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

'''
        pass

    def deregisterCacheFormat(self, cacheFormatName): 
        '''deregisterCacheFormat(self, cacheFormatName)
Arguments:
	[in]	cacheFormatName = MString

Deregister the specified cache format with Maya.'''
        pass

    def registerUIStrings(self, registerMStringResources, pluginStringsProc): 
        '''registerUIStrings(self, registerMStringResources, pluginStringsProc)
Arguments:
	[in]	registerMStringResources = MFnPlugin.MInitializeFunction
	[in]	pluginStringsProc = MString

Set the callback and procedure names of routines that register
plugin string resources and optionally load localized values for
them.'''
        pass

    def vendor(self): 
        '''vendor(self) -> MString
Returns: Returns:
An MString containing the vendor name

Return the vendor string supplied in the  MFnPlugin 
constructor.'''
        pass

    def setName(self, newName, makeUnique): 
        '''setName(self, newName, makeUnique)
Arguments:
	[in]	newName = MString
	[in]	makeUnique = bool

Set the name by which Maya knows this plug-in.'''
        pass

    def registerCacheFormat(self, cacheFormatName, creatorFunction): 
        '''registerCacheFormat(self, cacheFormatName, creatorFunction)
Arguments:
	[in]	cacheFormatName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction

Register a new cache format with Maya.'''
        pass

    def deregisterDragAndDropBehavior(self, behaviorName): 
        '''deregisterDragAndDropBehavior(self, behaviorName)
Arguments:
	[in]	behaviorName = MString

Deregister the given drag and drop behavior from Maya.'''
        pass

    def registerCommand(self, commandName, creatorFunction, createSyntaxFunction): 
        '''registerCommand(self, commandName, creatorFunction, createSyntaxFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	createSyntaxFunction = MFnPlugin.MCreateSyntaxFunction

Register a new command with Maya. Once registered, the command
can be invoked from MEL in a manner identical to built-in Maya
commands.'''
        pass

    def registerShape(self, typeName, typeId, creatorFunction, initFunction, uiCreatorFunction, classification): 
        '''registerShape(self, typeName, typeId, creatorFunction, initFunction, uiCreatorFunction, classification)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	initFunction = MFnPlugin.MInitializeFunction
	[in]	uiCreatorFunction = MFnPlugin.MCreatorFunction
	[in]	classification = MString

Registers the given user defined shape node with Maya. Once
registered, the shape can be used from MEL in a manner identical to
built-in Maya nodes.'''
        pass

    def deregisterIkSolver(self, ikSolverName): 
        '''deregisterIkSolver(self, ikSolverName)
Arguments:
	[in]	ikSolverName = MString

Deregister the specified ik-solver with Maya. NOTE: this method
is obsolete. Instead, register the IK solver as a node as described
in the example plug-in simpleSolverNode.cpp.'''
        pass

    def registerNode(self, typeName, typeId, creatorFunction, initFunction, type, classification): 
        '''registerNode(self, typeName, typeId, creatorFunction, initFunction, type, classification)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	initFunction = MFnPlugin.MInitializeFunction
	[in]	type = MPxNode.Type
	[in]	classification = MString

Register a new dependency node with Maya. Once registered, the
node can be used from MEL in a manner identical to built-in Maya
nodes.'''
        pass

    def deregisterData(self, typeId): 
        '''deregisterData(self, typeId)
Arguments:
	[in]	typeId = MTypeId

Deregister the given user defined data type from Maya.'''
        pass

    def deregisterConstraintCommand(self, commandName): 
        '''deregisterConstraintCommand(self, commandName)
Arguments:
	[in]	commandName = MString

Deregister the user defined constraint command from Maya. Once
deregistered the command can no longer be invoked from MEL.'''
        pass

    def registerDragAndDropBehavior(self, behaviorName, creatorFunction): 
        '''registerDragAndDropBehavior(self, behaviorName, creatorFunction)
Arguments:
	[in]	behaviorName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction

Register a new drag and drop behavior with Maya. Once
registered, the new behavior can be used to finish connections
between node drag and drops from the hyperGraph/hyperShade to other
nodes or Maya UI.'''
        pass

    def registerContextCommand(self, commandName, creatorFunction, toolCmdName, toolCmdCreator, toolCmdSyntax): 
        '''registerContextCommand(self, commandName, creatorFunction, toolCmdName, toolCmdCreator, toolCmdSyntax)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	toolCmdName = MString
	[in]	toolCmdCreator = MFnPlugin.MCreatorFunction
	[in]	toolCmdSyntax = MFnPlugin.MCreateSyntaxFunction

Register a new context command and a new tool command with Maya.
This version of registerContextCommand must be used if a tool
command (a class derived from  MPxToolCommand ) is
used within the context. The method newToolCommand of  MPxContext  will return
a new instance of the tool command that can be used in the
context.'''
        pass

    def registerRenderPassImpl(self, passImplId, passDef, creatorFunction, overload): 
        '''registerRenderPassImpl(self, passImplId, passDef, creatorFunction, overload)
Arguments:
	[in]	passImplId = MString
	[in]	passDef = MRenderPassDef
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	overload = bool

Register a new render pass implementation with Maya and
associate with the given render pass definition. If an
implementation with id passImplId has already been registered and
creatorFunction is the same as the already registered creator
function then the existing implementation will also be used for the
current pass (SAME instances). It is an error if the passImplId is
already defined and a different creatorFunction is used. If you
wish to associate DIFFERENT instances of the same pass
implementation with different passes, then use unique passImplIds
when registering each.'''
        pass

    def loadPath(self): 
        '''loadPath(self) -> MString
Returns: Returns:
An MString containing path name to the
location of the plugin.

Determine the path where the plugin was loaded.'''
        pass

    def unregisterMaterialInfo(self, materialInfoName): 
        '''unregisterMaterialInfo(self, materialInfoName)
Arguments:
	[in]	materialInfoName = MString

Deregister the specified material info type with Maya.'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: Returns:
An MString containing the plug-in name

Return the name by which Maya knows this plug-in.'''
        pass

    def registerControlCommand(self, commandName, creatorFunction): 
        '''registerControlCommand(self, commandName, creatorFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction

Register a new control command with Maya. Once registered, the
command can be invoked from MEL in a manner identical to built-in
Maya commands.'''
        pass

    def registerImageFile(self, imageFormatName, creatorFunction, imageFileExtensions): 
        '''registerImageFile(self, imageFormatName, creatorFunction, imageFileExtensions)
Arguments:
	[in]	imageFormatName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	imageFileExtensions = MStringArray

Register a new image file translator with Maya.'''
        pass

    def deregisterFileTranslator(self, translatorName): 
        '''deregisterFileTranslator(self, translatorName)
Arguments:
	[in]	translatorName = MString

Deregister the specified file translator with Maya.'''
        pass

    def unregisterBakeEngine(self, bakeEngineGenName): 
        '''unregisterBakeEngine(self, bakeEngineGenName)
Arguments:
	[in]	bakeEngineGenName = MString

Deregister the bake engine type with Maya.'''
        pass

    def isNodeRegistered(self, typeName): 
        '''isNodeRegistered(self, typeName) -> bool
Returns: Returns:
true if registered, false otherwise.

Arguments:
	[in]	typeName = MString

Queries if the given typeName has been registered by maya or
plugins.'''
        pass

    def apiVersion(self): 
        '''apiVersion(self) -> MString
Returns: Returns:
An MString containing the required API
version string

Return the required API version string supplied in the  MFnPlugin 
constructor.'''
        pass

    def findPlugin(self, pluginName): 
        '''findPlugin(self, pluginName) -> MObject
Returns: Returns:


An MObject
corresponding to the plugin if the plugin is loaded.
MObject::kNullObj
if the plugin isn't loaded.

Arguments:
	[in]	pluginName = MString

Returns an  MObject 
corresponding to the named plugin. If the plugin isn't loaded, the
 MObject  will be
kNullObj. This  MObject 
may be used in the same way as the  MObject  passed to the plugin's
initializePlugin() function. Do not hold onto this  MObject , if you need it again later,
call  findPlugin() 
again.'''
        pass

    def deregisterRenderPassImpl(self, passImplId): 
        '''deregisterRenderPassImpl(self, passImplId)
Arguments:
	[in]	passImplId = MString

Deregister the specified render pass implementation with Maya.
This will remove the implementation from all passes it is
associated with.'''
        pass

    def registerData(self, typeName, typeId, creatorFunction, type): 
        '''registerData(self, typeName, typeId, creatorFunction, type)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	type = MPxData.Type

Register a new data type with Maya. Once registered, the data
type can be passed between dependency nodes in a manner identical
to built-in Maya data types.'''
        pass

class MFnPluginData:
    '''User defined data function set for dependency node data.'''
    def __init__(self):
        pass


    def typeId(self): 
        '''typeId(self) -> MTypeId
Returns: Returns:
The unique MTypeId of the data held
in this instance

Return the unique  MTypeId  of the
user defined data that is held by this instance.'''
        pass

    def data(self): 
        '''data(self) -> MPxData
Returns: Returns:
A pointer to the MPxData
base class for the user defined data

Return a pointer to the user defined data held in this
instance.'''
        pass

    def create(self, id): 
        '''create(self, id) -> MObject
Returns: Returns:
An MObject that
represents an instance of the user defined data type. This will be
set to MObject::kNullObj if
the create failes.

Arguments:
	[in]	id = MTypeId

Create an instance of MPluginData and initialize it to represent
user defined data of the given type.'''
        pass

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

'''
        pass

    def constData(self): 
        '''constData(self) -> const MPxData
Returns: Returns:
A constant pointer to the MPxData
base class for the user defined data

Return a constant pointer to the user defined data held in this
instance.'''
        pass

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

'''
        pass

class MFnPointArrayData:
    '''Point array function set for dependency node data.'''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MPointArray

Set the instance to contain the points defined in the given
 MPointArray .'''
        pass

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

Arguments:
	[in]	arr = MPointArray

Create a new  MObject , attach it to this instance, and
initialize it to contain the data from the given  MPointArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MPointArray

Copy all the points in the instance into the given  MPointArray . No checking is done
by this class on sizes, so it is up to the user to ensure that the
given  MPointArray  is large enough to
hold the number of MPoints in the instance.'''
        pass

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

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of points in the instance

Return the number of points in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MPointArray
Returns: Returns:
A copy of the MPointArray held in this
instance

Get an  MPointArray  containing the points
stored in this instance. The  MPointArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set.'''
        pass

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

'''
        pass

class MFnPointLight:
    '''Manage Point Light dependency Nodes.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool

Creates a new point light dependency graph node and adds it to
the dependency graph. If the UIvisible parameter is true, the new
node will be connected to the light classification node (which
allows the UI to recognize the node as a light) and added to the
default light list. If UIvisible is false, the node will be created
in isolation.'''
        pass

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

'''
        pass

class MFnReflectShader:
    '''Manage Reflective Surface Shaders.'''
    def __init__(self):
        pass


    def setReflectedColor(self, reflected_color): 
        '''setReflectedColor(self, reflected_color)
Arguments:
	[in]	reflected_color = MColor

Sets the value of the "reflectedColor" attribute of a shader
node.'''
        pass

    def reflectedRayDepthLimit(self): 
        '''reflectedRayDepthLimit(self) -> short
Returns: Returns:
The value of the "reflectedRayDepthLimit" attribute of the
node.

Retrieves the value of the "reflectedRayDepthLimit" attribute of
a reflective shader node. This attribute represents the maximum
reflected ray depth used in the shading calculation.'''
        pass

    def setSpecularColor(self, specular_color): 
        '''setSpecularColor(self, specular_color)
Arguments:
	[in]	specular_color = MColor

Sets the value of the "specularColor" attribute of a shader
node.'''
        pass

    def setReflectedRayDepthLimit(self, reflected_ray_depth_limit): 
        '''setReflectedRayDepthLimit(self, reflected_ray_depth_limit)
Arguments:
	[in]	reflected_ray_depth_limit = short

Sets the value of the "reflectedRayDepthLimit" attribute of a
lambert shader node.'''
        pass

    def reflectivity(self): 
        '''reflectivity(self) -> float
Returns: Returns:
The value of the "reflectivity" attribute of the shader
node.

Retrieves the value of the "reflectivity" attribute of a
reflective shader node. This attribute represents the reflectivity
of the shader.'''
        pass

    def setReflectivity(self, reflect): 
        '''setReflectivity(self, reflect)
Arguments:
	[in]	reflect = float

Sets the value of the "reflectivity" attribute of a shader
node.'''
        pass

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

'''
        pass

    def specularColor(self): 
        '''specularColor(self) -> MColor
Returns: Returns:
The value of the "specularColor" attribute of the shader
node.

Retrieves the value of the "specularColor" attribute of a
reflective shader node. This attribute represents the color of
specular highlights produced by the shader.'''
        pass

    def reflectedColor(self): 
        '''reflectedColor(self) -> MColor
Returns: Returns:
The value of the "reflectedColor" attribute of the shader
node.

Retrieves the value of the "reflectedColor" attribute of a
reflective shader node. This attribute represents the color of
reflection produced by the shader.'''
        pass

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

'''
        pass

class MFnSet:
    '''Function Set for Sets of Objects.'''
    def __init__(self):
        pass


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

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

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

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

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

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

    class Restriction:
        '''Non-functional class.  Values for this enum:
        kEdgesOnly
        kVerticesOnly
        kFacetsOnly
        kNone
        kRenderableOnly
        kEditPointsOnly
'''
        def __init__(self):
            pass

    def addMember(self, plug): 
        '''addMember(self, plug)
Arguments:
	[in]	plug = MPlug

Add a new plug to the set.'''
        pass

    def removeMembers(self, list): 
        '''removeMembers(self, list)
Arguments:
	[in]	list = MSelectionList

Remove items of the selection list from the set.'''
        pass

    def restriction(self): 
        '''restriction(self) -> MFnSet.Restriction
Returns: Returns:
The type of restriction

Returns the type of membership restriction that this set
has.'''
        pass

    def intersectsWith(self, otherSet): 
        '''intersectsWith(self, otherSet) -> bool
Returns: Returns:
Boolean value indicating whether there was an intersection

Arguments:
	[in]	otherSet = MObject

Returns true if this set intersects with the given set. An
intersection occurs if there are any common members between the two
sets.'''
        pass

    def create(self, members, restriction): 
        '''create(self, members, restriction) -> MObject
Returns: Returns:
A handle for the new set object

Arguments:
	[in]	members = MSelectionList
	[in]	restriction = MFnSet.Restriction

Creates a new set dependency node and puts it in the dependency
graph.'''
        pass

    def getIntersection(self, setList, result): 
        '''getIntersection(self, setList, result)
Arguments:
	[in]	setList = MObjectArray
	[out]	result = MSelectionList

This method calculates the intersection of a list of sets. The
result will be the intersection of this set and the sets passed
into the method.'''
        pass

    def annotation(self): 
        '''annotation(self) -> MString
Returns: Returns:
The annotation string

Returns the annotation string for this set. This allows a
description of the set to be stored with it.'''
        pass

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

'''
        pass

    def getUnion(self, setList, result): 
        '''getUnion(self, setList, result)
Arguments:
	[in]	setList = MObjectArray
	[out]	result = MSelectionList

This method calculates the union of a list of sets. The result
will be the union of this set and the sets passed into the
method.'''
        pass

    def removeMember(self, plug): 
        '''removeMember(self, plug)
Arguments:
	[in]	plug = MPlug

Remove an plug from the set.'''
        pass

    def isMember(self, plug): 
        '''isMember(self, plug) -> bool
Returns: Returns:
A boolean value indicating whether the plug is a member

Arguments:
	[in]	plug = MPlug

Returns true if the given plug is a member of this set'''
        pass

    def getMembers(self, flatten, members): 
        '''getMembers(self, flatten, members)
Arguments:
	[out]	members = MSelectionList
	[in]	flatten = bool

Get the members of this set as a selection list. This
information is provided as a selection list so that all of the path
information is retained for DAG nodes.'''
        pass

    def addMembers(self, list): 
        '''addMembers(self, list)
Arguments:
	[in]	list = MSelectionList

Add a list of new objects to the set.'''
        pass

    def setAnnotation(self, annotation): 
        '''setAnnotation(self, annotation)
Arguments:
	[in]	annotation = MString

Sets the annotation string for this set. This allows a
description of the set to be stored with it.'''
        pass

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

'''
        pass

    def clear(self): 
        '''clear(self)
Removes all elements from this set'''
        pass

    def hasRestrictions(self): 
        '''hasRestrictions(self) -> bool
Returns: Returns:
A boolean value indicating whether this set has
restriction

Returns true if this function set has restrictions on the type
of objects that it may contain.'''
        pass

class MFnSingleIndexedComponent:
    '''Single indexed component function set.'''
    def __init__(self):
        pass


    def getCompleteData(self, numElements): 
        '''getCompleteData(self, numElements)
Arguments:
	[out]	numElements = int

Returns the number of elements for the complete component. A
complete component means that all elements are selected.'''
        pass

    def getElements(self, elements): 
        '''getElements(self, elements)
Arguments:
	[out]	elements = MIntArray

Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: Returns:
The new component

Arguments:
	[in]	compType = MFn.Type

Create a single indexed component of the given type. Allowable
types are'''
        pass

    def element(self, index): 
        '''element(self, index) -> int
Returns: Returns:
The index of the specified component

Arguments:
	[in]	index = int

Returns the specified element from the component.'''
        pass

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

'''
        pass

    def setCompleteData(self, numElements): 
        '''setCompleteData(self, numElements)
Arguments:
	[in]	numElements = int

Marks the component as complete (meaning all items are selected)
and uses the argument to identify the total number of elements
selected. If the component should contain N element indices, then
the range would be [0,N-1].'''
        pass

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

'''
        pass

    def addElement(self, element): 
        '''addElement(self, element)
Arguments:
	[in]	element = int

Add the specified element to the component.'''
        pass

    def addElements(self, elements): 
        '''addElements(self, elements)
Arguments:
	[in]	elements = MIntArray

Add the specified elements to the component.'''
        pass

class MFnSphereData:
    '''Sphere function set for dependency node data .'''
    def __init__(self):
        pass


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

'''
        pass

    def radius(self): 
        '''radius(self) -> double
Returns: Returns:
The radius

Return the radius of the sphere attached to this instance.'''
        pass

    def create(self, rad): 
        '''create(self, rad) -> MObject
Returns: Returns:
The new MObject

Arguments:
	[in]	rad = double

Create a new sphere of the given radius, and attach it to this
instance as an  MObject .'''
        pass

    def setRadius(self, rad): 
        '''setRadius(self, rad)
Arguments:
	[in]	rad = double

Change the radius of the sphere attached to this instance
instance as an  MObject .'''
        pass

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

'''
        pass

class MFnSpotLight:
    '''Manage Spot Light dependency Nodes.'''
    def __init__(self):
        pass


    def setBarnDoorAngle(self, which_door, barn_door_angle): 
        '''setBarnDoorAngle(self, which_door, barn_door_angle)
Arguments:
	[in]	which_door = MFnSpotLight.MBarnDoor
	[in]	barn_door_angle = double

Sets the value of the appropriate barn door angle attribute of a
light node.'''
        pass

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

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

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

    class MDecayRegion:
        '''Non-functional class.  Values for this enum:
        kThird
        kFirst
        kSecond
'''
        def __init__(self):
            pass

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

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

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

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

    class MBarnDoor:
        '''Non-functional class.  Values for this enum:
        kLeft
        kTop
        kRight
        kBottom
'''
        def __init__(self):
            pass

    def dropOff(self): 
        '''dropOff(self) -> double
Returns: Returns:
The value of the "dropOff" attribute of the light node.

Retrieves the value of the "dropOff" attribute of a light node.
This attribute represents the degree to which intensity of the
light decreases with increasing angular distance from the light
direction vector. Higher values represent more rapid intensity
dropoff.'''
        pass

    def penumbraAngle(self): 
        '''penumbraAngle(self) -> double
Returns: Returns:
The value of the "penumbraAngle" attribute of the light
node.

Retrieves the value of the "penumbraAngle" attribute of a light
node. This attribute represents the extra angle beyond the cone
angle used in soft shadow computations.'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool

Creates a new spotlight dependency graph node and adds it to the
dependency graph. If the UIvisible parameter is true, the new node
will be connected to the light classification node (which allows
the UI to recognize the node as a light) and added to the default
light list. If UIvisible is false, the node will be created in
isolation.'''
        pass

    def useDecayRegions(self): 
        '''useDecayRegions(self) -> bool
Returns: Returns:
The value of the "useDecayRegions" attribute of the light
node.

Retrieves the value of the "useDecayRegions" attribute of a
light node. This attribute determines whether or not the light uses
decay regions.'''
        pass

    def setDropOff(self, drop_off): 
        '''setDropOff(self, drop_off)
Arguments:
	[in]	drop_off = double

Sets the value of the "dropOff" attribute of a light node.'''
        pass

    def endDistance(self, which_region): 
        '''endDistance(self, which_region) -> float
Returns: Returns:
The value of the appropriate endDistance attribute of the light
node.

Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion

Retrieves the value of the end distance for the specified decay
regions. The end distances for the spotlight's 3 decay regions are
represented by the "endDistance1", "endDistance2", and
"endDistance3" attributes. This function retrieves the value of the
appropriate attribute.'''
        pass

    def coneAngle(self): 
        '''coneAngle(self) -> double
Returns: Returns:
The value of the "coneAngle" attribute of the light node.

Retrieves the value of the "coneAngle" attribute of a light
node. This attribute represents the angle that the spotlight cone
makes with the spotlight direction vector.'''
        pass

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

'''
        pass

    def setEndDistance(self, which_region, end_distance): 
        '''setEndDistance(self, which_region, end_distance)
Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion
	[in]	end_distance = float

Sets the value of the appropriate decay region end distance
attribute of a light node.'''
        pass

    def setBarnDoors(self, barn_doors): 
        '''setBarnDoors(self, barn_doors)
Arguments:
	[in]	barn_doors = bool

Sets the value of the "barnDoors" attribute of a light node.'''
        pass

    def setStartDistance(self, which_region, start_distance): 
        '''setStartDistance(self, which_region, start_distance)
Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion
	[in]	start_distance = float

Sets the value of the appropriate decay region start distance
attribute of a light node.'''
        pass

    def setPenumbraAngle(self, penumbra_angle): 
        '''setPenumbraAngle(self, penumbra_angle)
Arguments:
	[in]	penumbra_angle = double

Sets the value of the "penumbraAngle" attribute of a light
node.'''
        pass

    def barnDoors(self): 
        '''barnDoors(self) -> bool
Returns: Returns:
The value of the "barnDoors" attribute of the light node.

Retrieves the value of the "barnDoors" attribute of a light
node. This attribute determines whether or not the light uses barn
doors.'''
        pass

    def startDistance(self, which_region): 
        '''startDistance(self, which_region) -> float
Returns: Returns:
The value of the appropriate startDistance attribute of the
light node.

Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion

Retrieves the value of the start distance for the specified
decay regions. The start distances for the spotlight's 3 decay
regions are represented by the "startDistance1", "startDistance2",
and "startDistance3" attributes. This function retrieves the value
of the appropriate attribute.'''
        pass

    def setUseDecayRegions(self, use_decay_regions): 
        '''setUseDecayRegions(self, use_decay_regions)
Arguments:
	[in]	use_decay_regions = bool

Sets the value of the "useDecayRegions" attribute of a light
node.'''
        pass

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

'''
        pass

    def setConeAngle(self, cone_angle): 
        '''setConeAngle(self, cone_angle)
Arguments:
	[in]	cone_angle = double

Sets the value of the "coneAngle" attribute of a light node.'''
        pass

    def barnDoorAngle(self, which_door): 
        '''barnDoorAngle(self, which_door) -> double
Returns: Returns:
The value of the appropriate barn door angle attribute of the
light node.

Arguments:
	[in]	which_door = MFnSpotLight.MBarnDoor

Retrieves the value of the barn door angle for the specified
barn door. The barn door angles are represented by the
"leftBarnDoor", "rightBarnDoor", "topBarnDoor", and
"bottomBarnDoor" attributes. This function retrieves the value of
the appropriate attribute.'''
        pass

class MFnStringArrayData:
    '''String array function set for dependency node data.'''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MStringArray

Set the instance to contain the strings defined in the given
 MStringArray .'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MString
Returns: Returns:
The indicated MString

Arguments:
	[in]	index = int

Extract the indicated  MString  from the const instance. No
checking is done by this class to ensure that the index is valid -
use the length method to determine the size of the array. If the
instance is not attached to an  MObject , this method will return an
 MString  containing "".'''
        pass

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

Arguments:
	[in]	arr = MStringArray

Create a new  MObject , attach it to this instance, and
initialize it to contain the data from the given  MStringArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MStringArray

Copy all the strings in the instance into the given  MStringArray .'''
        pass

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

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of strings in the instance

Return the number of strings in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MStringArray
Returns: Returns:
A copy of the MStringArray held in this
instance

Return an  MStringArray  containing the
string array currently operated upon by the function set. The
 MStringArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set.'''
        pass

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

'''
        pass

class MFnStringData:
    '''String function set for dependency node data.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: Returns:
The new MObject

Create a new  MObject , attach it to this instance and
initialize it to the null string.'''
        pass

    def set(self, string): 
        '''set(self, string)
Arguments:
	[in]	string = MString

Set this instance to hold a copy of the given string.'''
        pass

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

'''
        pass

    def string(self): 
        '''string(self) -> MString
Returns: Returns:
An MString containing the string

Return a copy of the string held in this instance.'''
        pass

class MFnSubd:
    '''Subdivision surface function set.The easiest way to create a subdivision surface is probably to use
polyToSubdiv MEL command to create it from a polygon.
Alternativelly, the same functionality is available through the API
using  method. You can optionally specify
texture (uv) coordinates. UV coordinates are 2-d coordinates used
for mapping textures to the polygons of a surface. Each polygon
contains as many UV's as it has vertices. The UV values are not
shared and you can think of them as "owned" by a polygon, rather
than each vertex in that polygon.For the subdivision surfaces, the most important names are those of
the faces. Given a face name, each vertex on that face is named
based on that face. That does mean that each vertex will typically
have more than one name. Maya will always give you a unique name by
choosing the one that is numerically the smallest (in the 64 bit
sense). '''
    def __init__(self):
        pass


    def levelMaxCurrent(self): 
        '''levelMaxCurrent(self) -> int
Returns: Returns:
The finest level in the hierarchy

Returns the finest level that currently exist. As int as a
single face exists at a level, that level is counted. Note that
this not mean that all of the faces exist on all levels.'''
        pass

    def vertexBaseMeshGetWithId(self, space, positions, vertexIds): 
        '''vertexBaseMeshGetWithId(self, space, positions, vertexIds)
Arguments:
	[out]	positions = MPointArray
	[out]	vertexIds = MUint64Array
	[in]	space = MSpace.Space

Return all base mesh vertices in the array using their indices
but also provide the 64-bit names.'''
        pass

    def polygonCount(self, level): 
        '''polygonCount(self, level) -> int
Returns: Returns:
The number of polygons at the specified level

Arguments:
	[in]	level = int

Returns the number of polygons currently existing at the
specified level of the hierarchy.'''
        pass

    def getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps): 
        '''getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps)
Arguments:
	[in]	instanceNumber = int
	[out]	sets = MObjectArray
	[out]	comps = MObjectArray
	[in]	renderableSetsOnly = bool

Returns all the sets connected to the specified instance of this
mesh. For each set in the "sets" array there is a corresponding
entry in the "comps" array which are all the components in that
set. If the entire object is in a set, then the corresponding entry
in the comps array will have no elements in it.'''
        pass

    def updateAllEditsAndCreases(self): 
        '''updateAllEditsAndCreases(self)
If you have been editing offsets without updating the surface,
this function will save you. This will dirty up the complete
surface and recompute the positions of all the cvs, updating the
crease info along the way. Not cheap to call.'''
        pass

    def levelMaxAllowed(self): 
        '''levelMaxAllowed(self) -> int
Returns: Returns:
The maximum possibly value for the finest level in the
hierarchy

Returns the maximum level that can be created. You should
probably avoid fully subdividing the surface to that level as you
will most likelly just run out of memory.'''
        pass

    def vertexBaseMeshAddWithIndex(self, x, y, z, index): 
        '''vertexBaseMeshAddWithIndex(self, x, y, z, index)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	index = int

Very similar to vertexBaseMeshAdd, this gives you an advanced
option of specifying the index for the new vertex to be created.
You have to be extremelly careful to end up with the indices 0, 1,
... N-1 for N total vertices.'''
        pass

    def tessellateViaNurbs(self, parentOrOwner): 
        '''tessellateViaNurbs(self, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kMeshData

Arguments:
	[in]	parentOrOwner = MObject

Performs tesselation on this surface and create a new mesh in
the DAG. The parentOrOwner argument is used to specify the owner of
the new surface.'''
        pass

    def polygonGetCenterUV(self, polyId, u, v): 
        '''polygonGetCenterUV(self, polyId, u, v)
Arguments:
	[in]	polyId = MUint64
	[out]	u = double
	[out]	v = double

Return the UV values in the "center" of this polygon.'''
        pass

    def vertexEditsClearAllNonBase(self): 
        '''vertexEditsClearAllNonBase(self)
Find all vertices with edits and remove those edits, setting
them back to their original position.'''
        pass

    def polygonBaseMeshAddWithUVs(self, vertexCount, vertexIds, uValues, vValues): 
        '''polygonBaseMeshAddWithUVs(self, vertexCount, vertexIds, uValues, vValues) -> MUint64

Arguments:
	[in]	vertexCount = int
	[in]	vertexIds = int
	[in]	uValues = double
	[in]	vValues = double

Add a polygon at the base mesh level. You will need to use the
index names of the vertices (remember, they get their 64-bit names
only after they have been added to a polygon). Specify the UV
values as well.'''
        pass

    def evaluatePositionAndNormal(self, polyId, u, v, uvNormalized, pos, nrml): 
        '''evaluatePositionAndNormal(self, polyId, u, v, uvNormalized, pos, nrml)
Arguments:
	[in]	polyId = MUint64
	[in]	u = double
	[in]	v = double
	[in]	uvNormalized = bool
	[out]	pos = MPoint
	[out]	nrml = MVector

Evaluate the surface position and normal at the given parameter
point on the polygon. The limitation is that this cannot be a base
mesh polygon; i.e., it has to be at least level 1.'''
        pass

    def edgeIsCreased(self, edgeId): 
        '''edgeIsCreased(self, edgeId) -> bool
Returns: Returns:
True if the edge is creased, false otherwise

Arguments:
	[in]	edgeId = MUint64

Return true if the edge is creased.'''
        pass

    def edgeSetCrease(self, edgeId, creased): 
        '''edgeSetCrease(self, edgeId, creased)
Arguments:
	[in]	edgeId = MUint64
	[in]	creased = bool

Set the particular edge's crease state.'''
        pass

    def vertexIncidentPolygons(self, vertexId, polyList): 
        '''vertexIncidentPolygons(self, vertexId, polyList)
Arguments:
	[in]	vertexId = MUint64
	[out]	polyList = MUint64Array

Return the list of incident polygons as their 64-bit ids.'''
        pass

    def convertToNurbs(self, newNurbsSurfaces): 
        '''convertToNurbs(self, newNurbsSurfaces)
Arguments:
	[out]	newNurbsSurfaces = MObjectArray

Converts this surface to a set of nurbs surfaces.'''
        pass

    def vertexIdFromBaseVertexIndex(self, baseVertexIndex): 
        '''vertexIdFromBaseVertexIndex(self, baseVertexIndex) -> MUint64
Returns: Returns:
The 64-bit name of the vertex

Arguments:
	[in]	baseVertexIndex = int

Vertices are named using 64-bit integers. The base mesh vertices
will also have a simple 0, 1, 2, N-1 indices. Use this function to
compute the proper 64-bit name using the 0, 1, 2, ... indices.'''
        pass

    def vertexNormal(self, vertexId, normal): 
        '''vertexNormal(self, vertexId, normal)
Arguments:
	[in]	vertexId = MUint64
	[out]	normal = MVector

Returns the normal at the vertex'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kSubdivData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject

This method creates a copy of a given source subdivision
surface. After the copy this function set will operate on the new
subdivision surface.'''
        pass

    def vertexBaseMeshGet(self, space, positions): 
        '''vertexBaseMeshGet(self, space, positions)
Arguments:
	[out]	positions = MPointArray
	[in]	space = MSpace.Space

Return all base mesh vertices in the array using their indices
(not the 64-bit names).'''
        pass

    def evaluatePosition(self, polyId, u, v, uvNormalized, pos): 
        '''evaluatePosition(self, polyId, u, v, uvNormalized, pos)
Arguments:
	[in]	polyId = MUint64
	[in]	u = double
	[in]	v = double
	[in]	uvNormalized = bool
	[out]	pos = MPoint

Evaluate the surface position at the given parameter point on
the polygon. The limitation is that this cannot be a base mesh
polygon; i.e., it has to be at least level 1.'''
        pass

    def vertexIsCreased(self, vertexId): 
        '''vertexIsCreased(self, vertexId) -> bool
Returns: Returns:
Whether the vertex is creased or not

Arguments:
	[in]	vertexId = MUint64

Return true if the vertex is creased.'''
        pass

    def vertexEditGet(self, vertexId, space, edit): 
        '''vertexEditGet(self, vertexId, space, edit)
Arguments:
	[in]	vertexId = MUint64
	[out]	edit = MVector
	[in]	space = MSpace.Space

Get the offset of the specified vertex from its original
position. This vector really is  vertexPositionGet() 
-  vertexPositionGetNoEdit() .'''
        pass

    def levelFullySubdivideTo(self, level): 
        '''levelFullySubdivideTo(self, level)
Arguments:
	[in]	level = int

Fully subdivide the whole surface to the specified level. This
could be very expensive, so be careful, or you will run out of
memory. As a rule, each level has 4 times more faces than the
previous one.'''
        pass

    def edgeBetween(self, vertex1, vertex2): 
        '''edgeBetween(self, vertex1, vertex2) -> MUint64
Returns: Returns:
The name of the edge between the two

Arguments:
	[in]	vertex1 = MUint64
	[in]	vertex2 = MUint64

Return the name of the edge that connects the two vertices. If
the edge doesn't exist, it will be created.'''
        pass

    def vertexBaseIndexFromVertexId(self, vertexId): 
        '''vertexBaseIndexFromVertexId(self, vertexId) -> int
Returns: Returns:
The index in the base mesh vertex array of this vertex

Arguments:
	[in]	vertexId = MUint64

Given a 64-bit id of the vertex, return its index (0, 1, ...) if
it happens to be a base mesh vertex. It is an error to call this
function with a non base mesh vertex.'''
        pass

    def polygonEdgeCount(self, polyId): 
        '''polygonEdgeCount(self, polyId) -> int
Returns: Returns:
The number of edges on this polygon

Arguments:
	[in]	polyId = MUint64

The number of edges on the given polygon.'''
        pass

    def edgeIsBoundary(self, edgeId): 
        '''edgeIsBoundary(self, edgeId) -> bool
Returns: Returns:
True if the edge is a boundary edge, false otherwise.

Arguments:
	[in]	edgeId = MUint64

Test if the edge specified is a boundary edge or not.'''
        pass

    def vertexCreaseRelevant(self, vertexId): 
        '''vertexCreaseRelevant(self, vertexId) -> bool
Returns: Returns:
Whether the vertex has relevant crease information

Arguments:
	[in]	vertexId = MUint64

Return true if the crease of the vertex is a relevant piece of
information. The vertex inherits the crease state from its parent.
So, its crease state is relevant only if different from its parent
(or if there is no direct parent vertex).'''
        pass

    def edgeAdjacentPolygon(self, edgeId, polys): 
        '''edgeAdjacentPolygon(self, edgeId, polys)
Arguments:
	[in]	edgeId = MUint64
	[out]	polys = MUint64Array

Return the polygons adjacent to this edge. There can be at most
two, as non-manifold topology is not allowed.'''
        pass

    def evaluateNormal(self, polyId, u, v, uvNormalized, nrml): 
        '''evaluateNormal(self, polyId, u, v, uvNormalized, nrml)
Arguments:
	[in]	polyId = MUint64
	[in]	u = double
	[in]	v = double
	[in]	uvNormalized = bool
	[out]	nrml = MVector

Evaluate the surface normal at the given parameter point on the
polygon. The limitation is that this cannot be a base mesh polygon;
i.e., it has to be at least level 1.'''
        pass

    def vertexIsBoundary(self, vertexId): 
        '''vertexIsBoundary(self, vertexId) -> bool
Returns: Returns:
Whether the vertex is boundary or not

Arguments:
	[in]	vertexId = MUint64

Return true if the vertex is a boundary vertex.'''
        pass

    def polygonChildren(self, polyId, children): 
        '''polygonChildren(self, polyId, children)
Arguments:
	[in]	polyId = MUint64
	[out]	children = MUint64Array

Returns the list of children polygons on the given polygon. If
the children array is not empty, we will just append to it.'''
        pass

    def vertexEditSet(self, vertexId, edit, updateEdits, space): 
        '''vertexEditSet(self, vertexId, edit, updateEdits, space)
Arguments:
	[in]	vertexId = MUint64
	[in]	edit = MVector
	[in]	updateEdits = bool
	[in]	space = MSpace.Space

Set the original position offset for the given vertex.'''
        pass

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

'''
        pass

    def polygonBaseMeshAdd(self, vertexCount, vertexIndex): 
        '''polygonBaseMeshAdd(self, vertexCount, vertexIndex) -> MUint64
Returns: Returns:
The name of the newly created polygon

Arguments:
	[in]	vertexCount = int
	[in]	vertexIndex = int

Add a polygon at the base mesh level. You will need to use the
index names of the vertices (remember, they get their 64-bit names
only after they have been added to a polygon).'''
        pass

    def getConnectedShaders(self, instanceNumber, shaders, faces, indices): 
        '''getConnectedShaders(self, instanceNumber, shaders, faces, indices)
Arguments:
	[in]	instanceNumber = int
	[out]	shaders = MObjectArray
	[out]	faces = MUint64Array
	[out]	indices = MIntArray

Returns all the shaders (sets) connected to the specified
instance of this subdivision surface and two arrays indicating
face/shader assignments. For each face in the face array, there is
a corresponding entry in the indices array to indicate the assigned
shader in the shader array.'''
        pass

    def edgeIsValid(self, edgeId): 
        '''edgeIsValid(self, edgeId) -> bool
Returns: Returns:
True if the edge name is valid, false otherwise.

Arguments:
	[in]	edgeId = MUint64

Returns true if the specified edge name is valid.'''
        pass

    def vertexIsValid(self, vertexId): 
        '''vertexIsValid(self, vertexId) -> bool
Returns: Returns:
Whether the vertex is valid or not. Valid means that the vertex
has been instantiated on the surface. Not all vertices at all
levels exist by default. A vertex only exists if it was created at
the time the subdiv was first created or if the subdiv was
refined.

Arguments:
	[in]	vertexId = MUint64

Return true if the vertex is a valid vertex.'''
        pass

    def polygonCountMaxWithGivenBaseMesh(self, level): 
        '''polygonCountMaxWithGivenBaseMesh(self, level) -> int
Returns: Returns:
The number of polygons at the given level if you were to fully
subdivide at that level.

Arguments:
	[in]	level = int

If you were to fully subdivide at a given level, how many
polygons would you have at that level? This function will tell you
and possibly save you from running out of memory if you go too
deep. Note that this is exactly the same as "polygonCount" for
levels 0 and 1.'''
        pass

    def vertexPositionSet(self, vertexId, updateEdits, space, position): 
        '''vertexPositionSet(self, vertexId, updateEdits, space, position)
Arguments:
	[in]	vertexId = MUint64
	[out]	position = MPoint
	[in]	updateEdits = bool
	[in]	space = MSpace.Space

Set the position of the vertex with a given name.'''
        pass

    def collapse(self, level, makeNewNodeInvisible): 
        '''collapse(self, level, makeNewNodeInvisible) -> MObject
Returns: Returns:
The new collapsed subdivision object

Arguments:
	[in]	level = int
	[in]	makeNewNodeInvisible = bool

This method creates a copy of a given source subdivision surface
collapsed by the given number of levels. After the collapse this
function set will operate on the new subdivision surface.'''
        pass

    def createBaseMesh(self, reverseNormal, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, parentOrOwner): 
        '''createBaseMesh(self, reverseNormal, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, parentOrOwner) -> MObject

Arguments:
	[in]	reverseNormal = bool
	[in]	numVertices = int
	[in]	numPolygons = int
	[in]	vertexArray = MPointArray
	[in]	polygonCounts = MIntArray
	[in]	polygonConnects = MIntArray
	[in]	parentOrOwner = MObject

Creates a new subdivision surface given an array of vertices and
connection information and sets this function set to operate on the
new surface.'''
        pass

    def editsPending(self): 
        '''editsPending(self) -> int
Returns: Returns:
Edits pending (1) or not (0).

As the new hierarchical vertex offsets are being introduced, you
can choose to not apply them to the surface immediatelly. If you do
that, the number of edits pending will increase. Any edits are not
actually made until you call "updateEdits". This functions lets you
know if you need to call it or not.'''
        pass

    def vertexEditsSetAllNonBase(self, vertexIds, edits, space): 
        '''vertexEditsSetAllNonBase(self, vertexIds, edits, space)
Arguments:
	[in]	vertexIds = MUint64Array
	[in]	edits = MVectorArray
	[in]	space = MSpace.Space

Given an array of vertex names and the offsets from their
original positions, set the new vertex positions.'''
        pass

    def vertexChildren(self, vertexId, children): 
        '''vertexChildren(self, vertexId, children)
Arguments:
	[in]	vertexId = MUint64
	[out]	children = MUint64Array

Returns the "children" of the particular vertex if they exist.
The children are defined as the finer-level version of the current
vertex plus the neighbors of that vertex. For a valence n vertex
this means 2n+1 vertices are returned if a finer level exists.'''
        pass

    def vertexEditsGetAllNonBase(self, vertexIds, edits, space): 
        '''vertexEditsGetAllNonBase(self, vertexIds, edits, space)
Arguments:
	[in]	vertexIds = MUint64Array
	[in]	edits = MVectorArray
	[in]	space = MSpace.Space

Returns all the vertices below the base mesh that have been
modified from their original position (the original position is
specified by the position of the base mesh vertices). The two
arrays will be of the same length upon return. Length 0 would
suggest that there have been no edits from the original
positions.'''
        pass

    def edgeCreaseRelevant(self, edgeId): 
        '''edgeCreaseRelevant(self, edgeId) -> bool
Returns: Returns:
Whether the edge has relevant crease information

Arguments:
	[in]	edgeId = MUint64

Return true if the crease of the edge is a relevant piece of
information. The edge inherits the crease state from its parent.
So, its crease state is relevant only if different from its parent
(or if there is no direct parent edge).'''
        pass

    def polygonVertices(self, polyId, vertexIds): 
        '''polygonVertices(self, polyId, vertexIds)
Arguments:
	[in]	polyId = MUint64
	[out]	vertexIds = MUint64Array

Given the polygon, return its vertices. The vertices are at the
same level as the polygon.'''
        pass

    def polygonGetVertexUVs(self, polyId, uValues, vValues): 
        '''polygonGetVertexUVs(self, polyId, uValues, vValues)
Arguments:
	[in]	polyId = MUint64
	[out]	uValues = MDoubleArray
	[out]	vValues = MDoubleArray

Get the vertex UVs from the polygon. The values come back in
exactly the same order as the polygon vertices do.'''
        pass

    def vertexValence(self, vertexId): 
        '''vertexValence(self, vertexId) -> int
Returns: Returns:
The finest level in the hierarchy

Arguments:
	[in]	vertexId = MUint64

Returns the valence (number of incident edges) of the given
vertex.'''
        pass

    def vertexCount(self, level): 
        '''vertexCount(self, level) -> int
Returns: Returns:
The number of vertices at the given level

Arguments:
	[in]	level = int

Returns the finest vertex count at a particular level. These are
the vertices that are currently instantiated.'''
        pass

    def polygonHasVertexUVs(self, polyId): 
        '''polygonHasVertexUVs(self, polyId) -> bool
Returns: Returns:
True if there were explicitly specified UVs on this
polygon.

Arguments:
	[in]	polyId = MUint64

Returns true if there are user specified UVs on this
polygon.'''
        pass

    def tesselate(self, uniform, depth, sample, parentOrOwner): 
        '''tesselate(self, uniform, depth, sample, parentOrOwner) -> MObject
Returns: Returns:


If parentOrOwner is NULL then the transform for this surface is
returned
If parentOrOwner is a DAG object then the new surface shape is
returned
The surface geometry is returned if parentOrOwner is of type
kMeshData

Arguments:
	[in]	uniform = bool
	[in]	depth = int
	[in]	sample = int
	[in]	parentOrOwner = MObject

Performs tesselation on this surface and create a new mesh in
the DAG. The parentOrOwner argument is used to specify the owner of
the new surface.'''
        pass

    def creasesGetAll(self, vertexIds, edgeIds): 
        '''creasesGetAll(self, vertexIds, edgeIds)
Arguments:
	[out]	vertexIds = MUint64Array
	[out]	edgeIds = MUint64Array

Returns all creases on the subdivision surface in two arrays of
64-bit ids; one for the vertices, one for edges.'''
        pass

    def getCubicSpline(self, polyId, vertices): 
        '''getCubicSpline(self, polyId, vertices) -> bool
Returns: Returns:
True if we can make the conversion, false otherwise

Arguments:
	[in]	polyId = MUint64
	[out]	vertices = MPointArray

Some of the faces (usually at level 2 or below) happen to be
exactly the same as uniform bi-cubic B-splines. This routine will
return the 16 points that define such spline.'''
        pass

    def vertexPositionGetNoEdit(self, vertexId, space, position): 
        '''vertexPositionGetNoEdit(self, vertexId, space, position)
Arguments:
	[in]	vertexId = MUint64
	[out]	position = MPoint
	[in]	space = MSpace.Space

What would the position of this vertex be if there were no
edits; i.e., what was its original position.'''
        pass

    def polygonSetUseUVs(self, polyId, useThem): 
        '''polygonSetUseUVs(self, polyId, useThem)
Arguments:
	[in]	polyId = MUint64
	[in]	useThem = bool

If this is set, the polygon will use the user specified UVs.'''
        pass

    def updateSubdSurface(self): 
        '''updateSubdSurface(self)
Signal that this subdivision surface has changed and needs to
redraw itself.'''
        pass

    def polygonEdges(self, polyId, edgeIds): 
        '''polygonEdges(self, polyId, edgeIds)
Arguments:
	[in]	polyId = MUint64
	[out]	edgeIds = MUint64Array

Given the polygon, return its edges. The edges are at the same
level as the polygon.'''
        pass

    def vertexBaseMeshSet(self, space, positions): 
        '''vertexBaseMeshSet(self, space, positions)
Arguments:
	[out]	positions = MPointArray
	[in]	space = MSpace.Space

Set the positions for the base mesh vertices using the 0, 1,...
indexing instead of the 64-bit vertex names.'''
        pass

    def creasesSetAll(self, vertexIds, edgeIds): 
        '''creasesSetAll(self, vertexIds, edgeIds)
Arguments:
	[in]	vertexIds = MUint64Array
	[in]	edgeIds = MUint64Array

Set the creases on all vertices and edges with a given 64-bit
name. Note that the combination of  creasesGetAll() 
and  creasesSetAll() 
will not exactly duplicate the crease information between two
surfaces.'''
        pass

    def edgeCount(self, level): 
        '''edgeCount(self, level) -> int
Returns: Returns:
Number of edges at the given level

Arguments:
	[in]	level = int

Returns the number of edges at a level.'''
        pass

    def edgeVertices(self, edgeId, v1, v2): 
        '''edgeVertices(self, edgeId, v1, v2)
Arguments:
	[in]	edgeId = MUint64
	[out]	v1 = MUint64
	[out]	v2 = MUint64

Given an edge, return the two vertices at its ends.'''
        pass

    def creasesClearAll(self): 
        '''creasesClearAll(self)
Clear all crease information from this surface. No vertices or
edges will be creased after this function completes.'''
        pass

    def vertexPositionGet(self, vertexId, space, position): 
        '''vertexPositionGet(self, vertexId, space, position)
Arguments:
	[in]	vertexId = MUint64
	[out]	position = MPoint
	[in]	space = MSpace.Space

Get the position of the vertex with a given name.'''
        pass

    def edgeChildren(self, edgeId, children): 
        '''edgeChildren(self, edgeId, children)
Arguments:
	[in]	edgeId = MUint64
	[out]	children = MUint64Array

Returns the "children" of the particular edge. If the edge has
children, there will always be two child edges.'''
        pass

    def polygonSetVertexUVs(self, polyId, uValues, vValues): 
        '''polygonSetVertexUVs(self, polyId, uValues, vValues)
Arguments:
	[in]	polyId = MUint64
	[in]	uValues = MDoubleArray
	[in]	vValues = MDoubleArray

Set the UV values on the polygon.'''
        pass

    def polygonSubdivide(self, polyId): 
        '''polygonSubdivide(self, polyId)
Arguments:
	[in]	polyId = MUint64

Subdivide the given polygon into 4 children (if this happens to
be the level 0 polygon you will get as many children as that
polygon has edges).'''
        pass

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

'''
        pass

    def vertexBaseMeshAdd(self, x, y, z): 
        '''vertexBaseMeshAdd(self, x, y, z) -> int
Returns: Returns:
The index of the newly created vertex. It will be -1 if the
creation failed.

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

Add a vertex to the base mesh and return its "index" name. Note
that it will not have a valid 64-bit name until you actually create
a polygon that holds it.'''
        pass

    def polygonVertexCount(self, polyId): 
        '''polygonVertexCount(self, polyId) -> int
Returns: Returns:
The number of vertices on this polygon

Arguments:
	[in]	polyId = MUint64

How many vertices on a given polygon? The vertices are at the
same level as the polygon.'''
        pass

    def vertexSetCrease(self, vertexId, creased): 
        '''vertexSetCrease(self, vertexId, creased)
Arguments:
	[in]	vertexId = MUint64
	[in]	creased = bool

Set the particular vertex' crease state.'''
        pass

    def polygonHasChildren(self, polyId): 
        '''polygonHasChildren(self, polyId) -> bool
Returns: Returns:
Whether the polygon has children.

Arguments:
	[in]	polyId = MUint64

Returns whether or not the given polygon has children.'''
        pass

    def vertexBaseMeshSetWithId(self, space, positions, vertexIds): 
        '''vertexBaseMeshSetWithId(self, space, positions, vertexIds)
Arguments:
	[out]	positions = MPointArray
	[out]	vertexIds = MUint64Array
	[in]	space = MSpace.Space

Set the positions for the base mesh vertices using the 64-bit
names. The ordering of the elements in the array is irrelevant. The
edits will be automatically updated (i.e.,  editsPending() 
will return 0 after the call to this function).'''
        pass

    def editsUpdateAll(self): 
        '''editsUpdateAll(self)
If there are pending edits, this function will update the
surface so that there are no pending edits.'''
        pass

    def vertexIncidentEdges(self, vertexId, edgeList): 
        '''vertexIncidentEdges(self, vertexId, edgeList)
Arguments:
	[in]	vertexId = MUint64
	[out]	edgeList = MUint64Array

Return the list of incident edges as their 64-bit ids.'''
        pass

    def polygonIsValid(self, polygonId): 
        '''polygonIsValid(self, polygonId) -> bool
Returns: Returns:
Whether the polygon is valid or not. Valid means that the
polygon has been instantiated on the surface. Not all polygons at
all levels exist by default. A polygon only exists if it was
created at the time the subdiv was first created or if the subdiv
was refined.

Arguments:
	[in]	polygonId = MUint64

Return true if the polygon is a valid polygon.'''
        pass

    def vertexAdjacentVertices(self, vertexId, vertList): 
        '''vertexAdjacentVertices(self, vertexId, vertList)
Arguments:
	[in]	vertexId = MUint64
	[out]	vertList = MUint64Array

Return the list of adjacent vertices as their 64-bit ids.'''
        pass

class MFnSubdData:
    '''Subdiv Surface function set for dependency node data.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: Returns:
The new MObject

Create a new  MObject , attach it to this instance and
initialize it with a data block capable of holding a Subdivision
Surface.'''
        pass

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

'''
        pass

class MFnSubdNames:
    '''Manipulate Subdivision Surface vertex, edge and face ids.'''
    def __init__(self):
        pass


    def levelOneFaceIdFromIndex(self, index): 
        '''levelOneFaceIdFromIndex(self, index) -> MUint64

Arguments:
	[in]	index = int

Given a level 1 face name as integer, return it as a 64-bit
name.'''
        pass

    def nonBaseFaceEdges(self, id, edge1, edge2, edge3, edge4): 
        '''nonBaseFaceEdges(self, id, edge1, edge2, edge3, edge4)
Arguments:
	[in]	id = MUint64
	[in]	edge1 = MUint64
	[in]	edge2 = MUint64
	[in]	edge3 = MUint64
	[in]	edge4 = MUint64

Return the four edges on the given face. Note that the face
should not be a base mesh face (the level > 0).'''
        pass

    def level(self, id): 
        '''level(self, id) -> int

Arguments:
	[in]	id = MUint64

Given a 64-bit name, return the level of the component'''
        pass

    def fromMUint64(self, id, base, first, level, path, corner): 
        '''fromMUint64(self, id, base, first, level, path, corner)
Arguments:
	[in]	id = MUint64
	[out]	base = int
	[out]	first = int
	[out]	level = int
	[out]	path = int
	[out]	corner = int

Given a 64-bit name, compute the base face, first level face
index, level, path to the face and the corner choice at the finest
face.'''
        pass

    def toSelectionIndices(self, id, firstIndex, secondIndex): 
        '''toSelectionIndices(self, id, firstIndex, secondIndex)
Arguments:
	[in]	id = MUint64
	[out]	firstIndex = int
	[out]	secondIndex = int

Given a 64-bit name, return the two integers that will show up
as selection indices for that subd component.'''
        pass

    def levelOneFaceIndexFromId(self, id): 
        '''levelOneFaceIndexFromId(self, id) -> int

Arguments:
	[in]	id = MUint64

Given a 64-bit name, return the level one mesh face as an
integer, instead of 64-bit name.'''
        pass

    def levelOneFaceId(self, id): 
        '''levelOneFaceId(self, id) -> MUint64

Arguments:
	[in]	id = MUint64

Given a 64-bit name, return the level one face that is the
parent for the given component.'''
        pass

    def baseFaceId(self, id): 
        '''baseFaceId(self, id) -> MUint64

Arguments:
	[in]	id = MUint64

Given a 64-bit name, return the 64-bit name of the base face
that is the parent of the given component.'''
        pass

    def base(self, id): 
        '''base(self, id) -> int

Arguments:
	[in]	id = MUint64

Given a 64-bit name, return the base mesh face.'''
        pass

    def baseFaceIndexFromId(self, id): 
        '''baseFaceIndexFromId(self, id) -> int

Arguments:
	[in]	id = MUint64

Same as base().'''
        pass

    def nonBaseFaceVertices(self, id, vertex1, vertex2, vertex3, vertex4): 
        '''nonBaseFaceVertices(self, id, vertex1, vertex2, vertex3, vertex4)
Arguments:
	[in]	id = MUint64
	[in]	vertex1 = MUint64
	[in]	vertex2 = MUint64
	[in]	vertex3 = MUint64
	[in]	vertex4 = MUint64

Return the four vertices on the given face. Note that the face
should not be a base mesh face (the level > 0).'''
        pass

    def baseFaceIdFromIndex(self, index): 
        '''baseFaceIdFromIndex(self, index) -> MUint64

Arguments:
	[in]	index = int

Given the index of the base face (0, 1, ... N-1), return its
64-bit name.'''
        pass

    def corner(self, id): 
        '''corner(self, id) -> int

Arguments:
	[in]	id = MUint64

One of the 4 possible choices of the vertex or an edge once
we're at the particular face.'''
        pass

    def fromSelectionIndices(self, id, firstIndex, secondIndex): 
        '''fromSelectionIndices(self, id, firstIndex, secondIndex)
Arguments:
	[in]	id = MUint64
	[in]	firstIndex = int
	[in]	secondIndex = int

Given the two integers that would show as selection indices for
the subd component, return the 64-bit name for that component.'''
        pass

    def path(self, id): 
        '''path(self, id) -> int

Arguments:
	[in]	id = MUint64

Given a 64-bit name, return from level 1 face down to the face
in question. Two bits per level for the four possible choices.'''
        pass

    def parentFaceId(self, id): 
        '''parentFaceId(self, id) -> MUint64

Arguments:
	[in]	id = MUint64

Given a 64-bit name of the face, return its parent face id. Note
that if the given face id is from a base face (ie. it is a face at
level 0), the returned face will be exactly the same.'''
        pass

    def toMUint64(self, id, base, first, level, path, corner): 
        '''toMUint64(self, id, base, first, level, path, corner)
Arguments:
	[in]	id = MUint64
	[in]	base = int
	[in]	first = int
	[in]	level = int
	[in]	path = int
	[in]	corner = int

Compute the 64-bit name given the base face index, first level
face index, level, path to the finest face and the corner choice.
The corner is zero (ignore) if the component is to be the face.'''
        pass

    def first(self, id): 
        '''first(self, id) -> int

Arguments:
	[in]	id = MUint64

Given a 64-bit name, return the index of the first child of the
base face.'''
        pass

class MFnTransform:
    '''Create and access transform nodes.The matrices are post-multiplied in Maya. For example, to transform
a point P from object-space to world-space (P') you would need to
post-multiply by the worldMatrix. (P' = P x WM)'''
    def __init__(self):
        pass


    def set(self, transform): 
        '''set(self, transform)
Arguments:
	[in]	transform = MTransformationMatrix

Change this transform to equal the given matrix.'''
        pass

    def scalePivot(self, space): 
        '''scalePivot(self, space) -> MPoint
Returns: Returns:
Scale pivot point in centimeters

Arguments:
	[in]	space = MSpace.Space

Returns the pivot around which the scale is applied. The pivot
will be in centimeters.'''
        pass

    def translateBy(self, vector, space): 
        '''translateBy(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Relatively change the translation component of this
transformation.'''
        pass

    def kShearMaxYZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 11'''
        pass

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

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

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

    def kShearMinYZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 10'''
        pass

    def kTranslateMinX(self):
        '''This is an enum of LimitType.
Description: 
Value: 18'''
        pass

    def kTranslateMinZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 22'''
        pass

    def kTranslateMaxZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 23'''
        pass

    def kTranslateMaxY(self):
        '''This is an enum of LimitType.
Description: 
Value: 21'''
        pass

    def kTranslateMaxX(self):
        '''This is an enum of LimitType.
Description: 
Value: 19'''
        pass

    def kTranslateMinY(self):
        '''This is an enum of LimitType.
Description: 
Value: 20'''
        pass

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

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

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

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

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

    def kRotateMaxZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 17'''
        pass

    def kRotateMaxY(self):
        '''This is an enum of LimitType.
Description: 
Value: 15'''
        pass

    def kRotateMaxX(self):
        '''This is an enum of LimitType.
Description: 
Value: 13'''
        pass

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

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

    def kRotateMinY(self):
        '''This is an enum of LimitType.
Description: 
Value: 14'''
        pass

    def kRotateMinX(self):
        '''This is an enum of LimitType.
Description: 
Value: 12'''
        pass

    def kRotateMinZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 16'''
        pass

    class LimitType:
        '''Non-functional class.  Values for this enum:
        kShearMaxYZ
        kScaleMaxZ
        kScaleMaxY
        kScaleMaxX
        kShearMinYZ
        kTranslateMinX
        kTranslateMinZ
        kTranslateMaxZ
        kTranslateMaxY
        kTranslateMaxX
        kTranslateMinY
        kScaleMinY
        kScaleMinX
        kScaleMinZ
        kShearMaxXZ
        kShearMaxXY
        kRotateMaxZ
        kRotateMaxY
        kRotateMaxX
        kShearMinXY
        kShearMinXZ
        kRotateMinY
        kRotateMinX
        kRotateMinZ
'''
        def __init__(self):
            pass

    def getTranslation(self, space): 
        '''getTranslation(self, space) -> MVector
Returns: Returns:
Translation vector in centimeters

Arguments:
	[in]	space = MSpace.Space

Retrieve the translation component of this transformation in
centimeters.'''
        pass

    def getRotation(self, rotation, order): 
        '''getRotation(self, rotation, order)
Arguments:
	[out]	rotation = double3
	[out]	order = MTransformationMatrix.RotationOrder

Retrieve the rotation component of this transformation. The
rotation is retrieved in  MSpace::kTransform 
space.'''
        pass

    def getShear(self, shear): 
        '''getShear(self, shear)
Arguments:
	[out]	shear = double3

Retrieve the shearing component of this transformation.'''
        pass

    def setRotatePivotTranslation(self, vector, space): 
        '''setRotatePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Set the rotate pivot translation in centimeters. This component
is used internally by maya when the user moves the rotate pivot, or
when the balance flag is true in the  MFnTransform::setRotatePivot 
method. It serves as a compensation that allows existing
transformations to be preserved when the rotate pivot is modified.
For the precise mathematics, refer to the transformation matrix
details in the description section of  MFnTransform .'''
        pass

    def rotateOrientation(self, space): 
        '''rotateOrientation(self, space) -> MQuaternion
Returns: Returns:
Rotateorientation

Arguments:
	[in]	space = MSpace.Space

Returns the rotation used to orient the local rotation space.
For the precise mathematics, refer to the transformation matrix
details in the description section of  MFnTransform .'''
        pass

    def setScalePivot(self, point, space, balance): 
        '''setScalePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

Set the pivot around which the scale is applied in
centimeters.'''
        pass

    def rotateByQuaternion(self, x, y, z, w, space): 
        '''rotateByQuaternion(self, x, y, z, w, space)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double
	[in]	space = MSpace.Space

Relatively change the rotation of this transformation using a
quaternion.'''
        pass

    def shearBy(self, shear): 
        '''shearBy(self, shear)
Arguments:
	[in]	shear = double3

Relatively shear this transformation.'''
        pass

    def create(self, parent): 
        '''create(self, parent) -> MObject
Returns: Returns:
The newly created transform node object

Arguments:
	[in]	parent = MObject

Creates a new transformation node. The new node is placed in the
DAG.'''
        pass

    def rotatePivot(self, space): 
        '''rotatePivot(self, space) -> MPoint
Returns: Returns:
Rotation pivot point in centimeters

Arguments:
	[in]	space = MSpace.Space

Returns the pivot about which the rotation is applied.'''
        pass

    def restPosition(self): 
        '''restPosition(self) -> MTransformationMatrix
Returns: Returns:
The transformation matrix equivalent to the transform's rest
position. This rest position will be identity unless the
"setRestPosition" method has been called.

Retrieve the saved rest position of this transform.'''
        pass

    def rotatePivotTranslation(self, space): 
        '''rotatePivotTranslation(self, space) -> MVector
Returns: Returns:
Scale pivot translation in centimeters

Arguments:
	[in]	space = MSpace.Space

Return the rotate pivot translation in centimeters. This
component is used internally by maya when the user moves the rotate
pivot, or when the balance flag is set to true in the
MfnTransform::setRotatePivot method. It serves as a compensation
that allows existing transformations to be preserved. For the
precise mathematics, refer to the transformation matrix details in
the description section of  MFnTransform .'''
        pass

    def rotateBy(self, rotation, order, space): 
        '''rotateBy(self, rotation, order, space)
Arguments:
	[in]	rotation = double3
	[in]	order = MTransformationMatrix.RotationOrder
	[in]	space = MSpace.Space

Relatively change the rotation component of this
transformation.'''
        pass

    def setRotation(self, rotation, order): 
        '''setRotation(self, rotation, order)
Arguments:
	[in]	rotation = double3
	[in]	order = MTransformationMatrix.RotationOrder

Change the rotation component of this transformation. The
rotation is set in  MSpace::kTransform 
space.'''
        pass

    def limitValue(self, type): 
        '''limitValue(self, type) -> double
Returns: Returns:
Current value of the specified limit as internal unit.

Arguments:
	[in]	type = MFnTransform.LimitType

Determine the current value of the specified limit.'''
        pass

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

'''
        pass

    def transformation(self): 
        '''transformation(self) -> MTransformationMatrix
Returns: Returns:
The transformation matrix represented by this transform.

Retrieve the transformation matrix represented by this
transform.'''
        pass

    def setTranslation(self, vector, space): 
        '''setTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Change the translation component of this transformation.'''
        pass

    def enableLimit(self, type, flag): 
        '''enableLimit(self, type, flag)
Arguments:
	[in]	type = MFnTransform.LimitType
	[in]	flag = bool

Enable or disable the limit value for the specified limit
type.'''
        pass

    def getRotationQuaternion(self, space, x, y, z, w): 
        '''getRotationQuaternion(self, space, x, y, z, w)
Arguments:
	[out]	x = double
	[out]	y = double
	[out]	z = double
	[out]	w = double
	[in]	space = MSpace.Space

Retrieve the rotation component of this transformation as a
quaternion. The only valid transformation spaces for this method
are  MSpace::kTransform 
and  MSpace::kWorld . All other
spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def rotationOrder(self): 
        '''rotationOrder(self) -> MTransformationMatrix.RotationOrder
Returns: Returns:
rotation order

Returns the rotation order for the transform matrix - the order
in which the Euler angles are applied to create the end
rotation.'''
        pass

    def setRotatePivot(self, point, space, balance): 
        '''setRotatePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

Set the rotate pivot in centimeters about which rotation is
applied.'''
        pass

    def setRestPosition(self, matrix): 
        '''setRestPosition(self, matrix)
Arguments:
	[in]	matrix = MTransformationMatrix

Change the saved rest position of this transform. The rest
position is not used internally by Maya. It is exclusively for use
from the API as a temporary cache, which can be set and restored
within a single Maya session. Note that the rest position is not
saved with the scene.'''
        pass

    def scalePivotTranslation(self, space): 
        '''scalePivotTranslation(self, space) -> MVector
Returns: Returns:
Scale pivot translation in centimeters

Arguments:
	[in]	space = MSpace.Space

Returns the scale pivot translation in centimeters. This
component is used as a compensation by maya when the user moves the
scale pivot, or when the balance flag is set to true in the
MfnTransform::setScalePivot method. The scale pivot translation
serves as a compensation that allows existing transformations to be
preserved when the scale pivot is modified. For the precise
mathematics, refer to the transformation matrix details in the
description section of  MFnTransform .'''
        pass

    def setScale(self, scale): 
        '''setScale(self, scale)
Arguments:
	[in]	scale = double3

Set the scaling component of this transformation.'''
        pass

    def setLimit(self, type, value): 
        '''setLimit(self, type, value)
Arguments:
	[in]	type = MFnTransform.LimitType
	[in]	value = double

Change the limit value for the specified limit type, and
automatically enable the limit to be true.'''
        pass

    def getScale(self, scale): 
        '''getScale(self, scale)
Arguments:
	[out]	scale = double3

Retrieve the scaling component of this transformation.'''
        pass

    def clearRestPosition(self): 
        '''clearRestPosition(self)
Clear the saved rest position of this transform.'''
        pass

    def resetFromRestPosition(self): 
        '''resetFromRestPosition(self)
Reset the transform to its rest position.'''
        pass

    def scaleBy(self, scale): 
        '''scaleBy(self, scale)
Arguments:
	[in]	scale = double3

Relatively scale this transformation.'''
        pass

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

'''
        pass

    def setShear(self, shear): 
        '''setShear(self, shear)
Arguments:
	[in]	shear = double3

Set the shearing component of this transformation.'''
        pass

    def isLimited(self, type): 
        '''isLimited(self, type) -> bool
Returns: Returns:
True or false, true means the limit is enabled.

Arguments:
	[in]	type = MFnTransform.LimitType

Determine if the specified limit attribute is enabled or
disabled.'''
        pass

    def setRotateOrientation(self, quat, space, balance): 
        '''setRotateOrientation(self, quat, space, balance)
Arguments:
	[in]	quat = MQuaternion
	[in]	space = MSpace.Space
	[in]	balance = bool

Set the rotation used to orient the local rotation space. For
the precise mathematics, refer to the transformation matrix details
in the description section of  MFnTransform .'''
        pass

    def setRotationOrder(self, order, reorder): 
        '''setRotationOrder(self, order, reorder)
Arguments:
	[in]	order = MTransformationMatrix.RotationOrder
	[in]	reorder = bool

Change the rotation order for the transform - the order in which
the Euler angles are applied to create the end rotation.'''
        pass

    def setScalePivotTranslation(self, vector, space): 
        '''setScalePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Set the scale pivot translation in centimeters. This component
is used internally by maya when the user moves the scale pivot, or
when the balance flag is set to true in the
MfnTransform::setScalePivot method. It serves as a compensation
that allows existing transformations to be preserved when the scale
pivot is modified. For the precise mathematics, refer to the
transformation matrix details in the description section of
 MFnTransform .'''
        pass

    def setRotationQuaternion(self, x, y, z, w, space): 
        '''setRotationQuaternion(self, x, y, z, w, space)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double
	[in]	space = MSpace.Space

Change the rotation component of this transformation using a
quaternion. The only valid transformation spaces for this method
are  MSpace::kTransform 
and  MSpace::kWorld . All other
spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

class MFnTripleIndexedComponent:
    '''Triple indexed component function set.'''
    def __init__(self):
        pass


    def getCompleteData(self, maxS, maxT, maxU): 
        '''getCompleteData(self, maxS, maxT, maxU)
Arguments:
	[out]	maxS = int
	[out]	maxT = int
	[out]	maxU = int

Returns the number of elements for the complete component. A
complete component means that all elements are selected.'''
        pass

    def getElement(self, index, sIndex, tIndex, uIndex): 
        '''getElement(self, index, sIndex, tIndex, uIndex)
Arguments:
	[in]	index = int
	[out]	sIndex = int
	[out]	tIndex = int
	[out]	uIndex = int

Get the specified element from the component.'''
        pass

    def getElements(self, sIndices, tIndices, uIndices): 
        '''getElements(self, sIndices, tIndices, uIndices)
Arguments:
	[out]	sIndices = MIntArray
	[out]	tIndices = MIntArray
	[out]	uIndices = MIntArray

Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: Returns:
The new component

Arguments:
	[in]	compType = MFn.Type

Create a triple indexed component of the given type. Allowable
types are'''
        pass

    def addElements(self, sIndices, tIndices, uIndices): 
        '''addElements(self, sIndices, tIndices, uIndices)
Arguments:
	[in]	sIndices = MIntArray
	[in]	tIndices = MIntArray
	[in]	uIndices = MIntArray

Add the specified elements to the component.'''
        pass

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

'''
        pass

    def setCompleteData(self, maxS, maxT, maxU): 
        '''setCompleteData(self, maxS, maxT, maxU)
Arguments:
	[in]	maxS = int
	[in]	maxT = int
	[in]	maxU = int

Marks the component as complete (meaning all items are selected)
and uses the argument to identify the total number of elements
selected. If the component should contain N element indices, then
the range would be [0,N-1].'''
        pass

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

'''
        pass

    def addElement(self, sIndex, tIndex, uIndex): 
        '''addElement(self, sIndex, tIndex, uIndex)
Arguments:
	[in]	sIndex = int
	[in]	tIndex = int
	[in]	uIndex = int

Add the specified element to the component.'''
        pass

class MFnTypedAttribute:
    '''Typed attribute function set.'''
    def __init__(self):
        pass


    def attrType(self): 
        '''attrType(self) -> MFnData.Type

Return the type of this attribute.'''
        pass

    def setDefault(self, defaultData): 
        '''setDefault(self, defaultData)
Arguments:
	[in]	defaultData = MObject

Set the default data for this attribute. The data can be created
using the appropriate MFn*Data function set.'''
        pass

    def create(self, full, brief, type, defaultData): 
        '''create(self, full, brief, type, defaultData) -> MObject
Returns: Returns:
Pointer to the new attribute object.

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	type = MFnData.Type
	[in]	defaultData = MObject

Create a new typed attribute with the given type.'''
        pass

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

'''
        pass

    def getDefault(self, defaultData): 
        '''getDefault(self, defaultData)
Arguments:
	[out]	defaultData = MObject

Get the default data for this attribute. The data can then be
operated on using the appropriate MFn*Data functionset.'''
        pass

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

'''
        pass

class MFnUint64SingleIndexedComponent:
    '''Single MUint64 indexed component function set.'''
    def __init__(self):
        pass


    def getCompleteData(self, numElements): 
        '''getCompleteData(self, numElements)
Arguments:
	[out]	numElements = MUint64

Returns the number of elements for the complete component. A
complete component means that all elements are selected.'''
        pass

    def getElements(self, elements): 
        '''getElements(self, elements)
Arguments:
	[out]	elements = MUint64Array

Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: Returns:
The new component

Arguments:
	[in]	compType = MFn.Type

Create a single indexed component of the given type. Allowable
types are'''
        pass

    def element(self, index): 
        '''element(self, index) -> MUint64
Returns: Returns:
The index of the specified component

Arguments:
	[in]	index = int

Returns the specified element from the component.'''
        pass

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

'''
        pass

    def setCompleteData(self, numElements): 
        '''setCompleteData(self, numElements)
Arguments:
	[in]	numElements = MUint64

Marks the component as complete (meaning all items are selected)
and uses the argument to identify the total number of elements
selected. If the component should contain N element indices, then
the range would be [0,N-1].'''
        pass

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

'''
        pass

    def addElement(self, element): 
        '''addElement(self, element)
Arguments:
	[in]	element = MUint64

Add the specified element to the component.'''
        pass

    def addElements(self, elements): 
        '''addElements(self, elements)
Arguments:
	[in]	elements = MUint64Array

Add the specified elements to the component.'''
        pass

class MFnUnitAttribute:
    '''Unit attribute Function set.'''
    def __init__(self):
        pass


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

Determine whether or not this attribute has a soft maximum value
set.'''
        pass

    def setMin(self, minValue): 
        '''setMin(self, minValue)
Arguments:
	[in]	minValue = MDistance

Set the minimum value for this attribute.'''
        pass

    def setSoftMin(self, minValue): 
        '''setSoftMin(self, minValue)
Arguments:
	[in]	minValue = MDistance

Set the soft minimum value for this attribute.'''
        pass

    def getDefault(self, defaultValue): 
        '''getDefault(self, defaultValue)
Arguments:
	[out]	defaultValue = MDistance

Gets the default value for this attribute.'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Last value, for counting.
Value: 4'''
        pass

    def kAngle(self):
        '''This is an enum of Type.
Description: Angular attribute.
Value: 1'''
        pass

    def kDistance(self):
        '''This is an enum of Type.
Description: Distance (linear) attribute.
Value: 2'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: Invalid unit type.
Value: 0'''
        pass

    def kTime(self):
        '''This is an enum of Type.
Description: Time attribute.
Value: 3'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kLast
        kAngle
        kDistance
        kInvalid
        kTime
'''
        def __init__(self):
            pass

    def create(self, full, brief, defaultValue): 
        '''create(self, full, brief, defaultValue) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	defaultValue = MDistance

Create a new unit attribute of type  distance  and return
it as an  MObject .'''
        pass

    def setMax(self, maxValue): 
        '''setMax(self, maxValue)
Arguments:
	[in]	maxValue = MDistance

Set the maximum value for this attribute.'''
        pass

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

Determine whether or not this attribute has a soft minimum value
set.'''
        pass

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

'''
        pass

    def setSoftMax(self, maxValue): 
        '''setSoftMax(self, maxValue)
Arguments:
	[in]	maxValue = MDistance

Set the soft maximum value for this attribute.'''
        pass

    def unitType(self): 
        '''unitType(self) -> MFnUnitAttribute.Type

Return the unit type of this attribute.'''
        pass

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

Determine whether or not this attribute has a maximum value
set.'''
        pass

    def getMin(self, minValue): 
        '''getMin(self, minValue)
Arguments:
	[out]	minValue = MDistance

Return the minimum value for this attribute.'''
        pass

    def getMax(self, maxValue): 
        '''getMax(self, maxValue)
Arguments:
	[out]	maxValue = MDistance

Return the maximum value for this attribute.'''
        pass

    def getSoftMax(self, maxValue): 
        '''getSoftMax(self, maxValue)
Arguments:
	[out]	maxValue = MDistance

Return the soft maximum value for this attribute.'''
        pass

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

Determine whether or not this attribute has a minimum value
set.'''
        pass

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

'''
        pass

    def getSoftMin(self, minValue): 
        '''getSoftMin(self, minValue)
Arguments:
	[out]	minValue = MDistance

Return the soft minimum value for this attribute.'''
        pass

    def setDefault(self, defaultValue): 
        '''setDefault(self, defaultValue)
Arguments:
	[in]	defaultValue = MDistance

Set a new default value for this attribute.'''
        pass

class MFnUInt64ArrayData:
    '''MUint64 array function set for dependency node data.'''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MUint64Array

Set the instance to contain the MUint64s defined in the given
 MUint64Array .'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MFnUInt64ArrayData.MUint64&
Returns: Returns:
The indicated MUint64

Arguments:
	[in]	index = int

Extract the indicated MUint64 from the instance. by the function
set. The MUint64 returned by this method is editable, so any
changes to the return instance also affects the  MObject  operated upon by this function
set.'''
        pass

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

Arguments:
	[in]	arr = MUint64Array

Create a new  MObject , attach it to this instance, and
initialize it to contain the data from the given  MUint64Array .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MUint64Array

Copy all the MUint64s in the instance into the given  MUint64Array .'''
        pass

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

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of MUint64s in the instance

Return the number of MUint64s in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MUint64Array
Returns: Returns:
A copy of the MUint64Array held in this
instance

Return an  MUint64Array  containing the
MUint64 array currently operated upon by the function set. The
 MUint64Array  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set.'''
        pass

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

'''
        pass

class MFnVectorArrayData:
    '''int array function set for dependency node data.'''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MVectorArray

Set the instance to contain the vectors defined in the given
 MVectorArray .'''
        pass

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

Arguments:
	[in]	arr = MVectorArray

Create a new  MObject , attach it to this instance, and
initialize it to contain the data from the given  MVectorArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MVectorArray

Copy all the vectors in the instance into the given  MVectorArray .'''
        pass

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

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
The number of vectors in the instance

Return the number of vectors in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MVectorArray
Returns: Returns:
A copy of the MVectorArray held in this
instance

Return an  MVectorArray  containing the
vector array currently operated upon by the function set. The
 MVectorArray  returned by this
method is editable, so any changes to the return instance also
affects the  MObject 
operated upon by this function set.'''
        pass

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

'''
        pass

class MFnVolumeLight:
    '''Manage volume Light dependency Nodes.'''
    def __init__(self):
        pass


    def setEmitAmbient(self, emit_ambient): 
        '''setEmitAmbient(self, emit_ambient)
Arguments:
	[in]	emit_ambient = bool

Sets the value of the "emitAmbient" attribute of a volume light
node.'''
        pass

    def setConeEndRadius(self, cone_end_radius): 
        '''setConeEndRadius(self, cone_end_radius)
Arguments:
	[in]	cone_end_radius = float

Sets the value of the "coneEndRadius" attribute of a volume
light node.'''
        pass

    def emitAmbient(self): 
        '''emitAmbient(self) -> bool
Returns: Returns:
The value of the "emitAmbient" attribute of the volume light
node.

Retrieves the value of the "emitAmbient" attribute.'''
        pass

    def colorRamp(self): 
        '''colorRamp(self) -> MRampAttribute
Returns: Returns:
The color ramp attribute

Retrieves the "colorRamp" attribute.'''
        pass

    def lightShape(self): 
        '''lightShape(self) -> MFnVolumeLight.MLightShape
Returns: Returns:
The value of the "lightShape" attribute of the volume light
node.

Retrieves the "lightShape" attribute of the light. The shape can
be one of the following.'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: Returns:
MObject
representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool

Creates a new volume light dependency graph node and adds it to
the dependency graph. If the UIvisible parameter is true, the new
node will be connected to the light classification node (which
allows the UI to recognize the node as a light) and added to the
default light list. If UIvisible is false, the node will be created
in isolation.'''
        pass

    def volumeLightDirection(self): 
        '''volumeLightDirection(self) -> MFnVolumeLight.MLightDirection
Returns: Returns:
The value of the "lightDirection" attribute of the volume light
node.

Retrieves the value of the "volumeLightDirection" attribute.'''
        pass

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

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

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

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

    class MLightShape:
        '''Non-functional class.  Values for this enum:
        kCylinderVolume
        kBoxVolume
        kConeVolume
        kSphereVolume
'''
        def __init__(self):
            pass

    def setLightShape(self, light_shape): 
        '''setLightShape(self, light_shape)
Arguments:
	[in]	light_shape = MFnVolumeLight.MLightShape

Sets the value of the "lightShape" attribute of a volume light
node. The shape can be one of the following:'''
        pass

    def kDownAxis(self):
        '''This is an enum of MLightDirection.
Description: Light travels down the axis, like a directional light pointing
in the negative Y direction.
Value: 2'''
        pass

    def kOutward(self):
        '''This is an enum of MLightDirection.
Description: Light travels outwared from the center of a box- or
sphere-shaped volume, and outward from the axis of a cylinder- or
cone-shaped volume.
Value: 0'''
        pass

    def kInward(self):
        '''This is an enum of MLightDirection.
Description: Light travels inward toward the center of a box- or
sphere-shaped volume, and inward toward the axis of a cylinder- or
cone-shaped volume.
Value: 1'''
        pass

    class MLightDirection:
        '''Non-functional class.  Values for this enum:
        kDownAxis
        kOutward
        kInward
'''
        def __init__(self):
            pass

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

'''
        pass

    def arc(self): 
        '''arc(self) -> float
Returns: Returns:
The value of the "arc" attribute of the volume light node.

Retrieves the value of the "arc" attribute. The arc is an
angular slice of the light about the y axis. The value can range
from 0 to 360 degrees.'''
        pass

    def setVolumeLightDirection(self, volume_light_direction): 
        '''setVolumeLightDirection(self, volume_light_direction)
Arguments:
	[in]	volume_light_direction = MFnVolumeLight.MLightDirection

Sets the value of the "volumeLightDirection" attribute of a
volume light node. The shape can be one of the following.'''
        pass

    def setArc(self, arc): 
        '''setArc(self, arc)
Arguments:
	[in]	arc = float

Sets the value of the "arc" attribute of a volume light
node.'''
        pass

    def penumbraRamp(self): 
        '''penumbraRamp(self) -> MRampAttribute
Returns: Returns:
The penumbra ramp attribute

Retrieves the "penumbraRamp" attribute.'''
        pass

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

'''
        pass

    def coneEndRadius(self): 
        '''coneEndRadius(self) -> float
Returns: Returns:
The value of the "coneEndRadius" attribute of the volume light
node.

Retrieves the value of the "coneEndRadius" attribute. The
coneEndRadius attribute determines the relative size of the one end
of the cone. At a value of 1.0 it is a cylinder, while at 0 it is a
cone.'''
        pass

class MGlobal:
    '''Static class providing common API global functions.'''
    def __init__(self):
        pass


    def unselectByName(self, name): 
        '''unselectByName(self, name)
Arguments:
	[in]	name = MString

Removes objects matching the pattern from the active selection
list.'''
        pass

    def upAxis(self): 
        '''upAxis(self) -> MVector

This method returns the model's current up axis.'''
        pass

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

This method returns true if, currently, the Z-axis is UP.'''
        pass

    def executePythonCommand(self, command, displayEnabled, undoEnabled, result): 
        '''executePythonCommand(self, command, displayEnabled, undoEnabled, result)
Arguments:
	[in]	command = MString
	[out]	result = MStringArray
	[in]	displayEnabled = bool
	[in]	undoEnabled = bool

This method is not available in Python.'''
        pass

    def addToModelAt(self, object, point, scale, rotation, rotOrder): 
        '''addToModelAt(self, object, point, scale, rotation, rotOrder)
Arguments:
	[in]	object = MObject
	[in]	point = MVector
	[in]	scale = double3
	[in]	rotation = double3
	[in]	rotOrder = MTransformationMatrix.RotationOrder

Adds the specified dag object to the DAG and transform the
object by the specified arguments. This method is only valid for
dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will
be returned.'''
        pass

    def kRemoveFromList(self):
        '''This is an enum of ListAdjustment.
Description: Remove the items from the list.
Value: 3'''
        pass

    def kReplaceList(self):
        '''This is an enum of ListAdjustment.
Description: Totally replace the list with the given items.
Value: 0'''
        pass

    def kXORWithList(self):
        '''This is an enum of ListAdjustment.
Description: For each item, remove it to the list if that are already
present, add it otherwise.
Value: 1'''
        pass

    def kAddToHeadOfList(self):
        '''This is an enum of ListAdjustment.
Description: Add to beginning of the list.
Value: 4'''
        pass

    def kAddToList(self):
        '''This is an enum of ListAdjustment.
Description: Add the items to the list.
Value: 2'''
        pass

    class ListAdjustment:
        '''Non-functional class.  Values for this enum:
        kRemoveFromList
        kReplaceList
        kXORWithList
        kAddToHeadOfList
        kAddToList
'''
        def __init__(self):
            pass

    def setHiliteList(self, list): 
        '''setHiliteList(self, list)
Arguments:
	[in]	list = MSelectionList

Sets the current hilite list. The current selection list is
unchanged.'''
        pass

    def getRichSelection(self, defaultToActiveSelection, richSelection): 
        '''getRichSelection(self, defaultToActiveSelection, richSelection)
Arguments:
	[out]	richSelection = MRichSelection
	[in]	defaultToActiveSelection = bool

Returns the current rich selection (usually the active selection
with any soft selection and symmetry applied). Optionally if no
rich selection exists, the current active selection can be returned
instead (reducing the need for duplicated code).'''
        pass

    def getAssociatedSets(self, list, setArray): 
        '''getAssociatedSets(self, list, setArray)
Arguments:
	[in]	list = MSelectionList
	[out]	setArray = MObjectArray

This utility method finds all the sets that the items in the
given selection list are members of.'''
        pass

    def stopErrorLogging(self): 
        '''stopErrorLogging(self)
This method disables output to the API error log but does not
close the log file.'''
        pass

    def selectionMethod(self): 
        '''selectionMethod(self) -> MGlobal.SelectionMethod

Determines the selection method that should be used in the
currently active viewport. This is useful as input to the
"selectFromScreen" functions.'''
        pass

    def optionVarStringValue(self, name, result): 
        '''optionVarStringValue(self, name, result) -> MString

Arguments:
	[in]	name = MString
	[in]	result = bool

This method is used to get the option variable value of type
string'''
        pass

    def kInteractive(self):
        '''This is an enum of MMayaState.
Description: Running with a UI.
Value: 0'''
        pass

    def kBatch(self):
        '''This is an enum of MMayaState.
Description: Running without a UI.
Value: 1'''
        pass

    def kBaseUIMode(self):
        '''This is an enum of MMayaState.
Description: Running in baseUI mode.
Value: 3'''
        pass

    def kLibraryApp(self):
        '''This is an enum of MMayaState.
Description: A standalone (
Value: 2'''
        pass

    class MMayaState:
        '''Non-functional class.  Values for this enum:
        kInteractive
        kBatch
        kBaseUIMode
        kLibraryApp
'''
        def __init__(self):
            pass

    def deleteNode(self, object): 
        '''deleteNode(self, object)
Arguments:
	[in]	object = MObject

Delete the given dag node or dependency graph node.'''
        pass

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

Returns a number describing the version of the Maya API at
runtime.'''
        pass

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

This method returns true if, currently, the Y-axis is UP.'''
        pass

    def errorLoggingIsOn(self): 
        '''errorLoggingIsOn(self) -> bool
Returns: Returns:
Boolean value: true Errors are being logged false
otherwise.

This method determines whether or not API errors are being
logged.'''
        pass

    def selectionMode(self): 
        '''selectionMode(self) -> MGlobal.MSelectionMode

Determines Maya's selection mode.'''
        pass

    def select(self, object, component, listAdjustment): 
        '''select(self, object, component, listAdjustment)
Arguments:
	[in]	object = MDagPath
	[in]	component = MObject
	[in]	listAdjustment = MGlobal.ListAdjustment

Put the given object or components on the active selection list.
If the component is null then the object in the dag path will be
selected, otherwise the given component will be selected.'''
        pass

    def resetToDefaultErrorLogPathName(self): 
        '''resetToDefaultErrorLogPathName(self)
Closes the current log file if it is open, and then resets the
log path to the default path. Logging is disabled and the log file
speicified by the default path is not opened. If logging is
disabled, it remains disabled. Use  startErrorLogging() 
to enable logging to the default log file. If the current path is
the default path, no action is taken, but an invalid parameter
error is returned.'''
        pass

    def errorLogPathName(self): 
        '''errorLogPathName(self) -> MString
Returns: Returns:
Error log path name

Determines the path name of the current error log file. Returns
the null string on failure.'''
        pass

    def setYAxisUp(self, rotateView): 
        '''setYAxisUp(self, rotateView)
Arguments:
	[in]	rotateView = bool

This method sets the flag to identify which axis is Up, and
rotates the ground plane around around the X-axis 90 degrees to get
the Y-Up from Z-Up.'''
        pass

    def executePythonCommandOnIdle(self, command, displayEnabled): 
        '''executePythonCommandOnIdle(self, command, displayEnabled)
Arguments:
	[in]	command = MString
	[in]	displayEnabled = bool

This method is not available in Python.'''
        pass

    def setMiscSelectionMask(self, mask): 
        '''setMiscSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask

Set the miscellaneous selection mask to the supplied value'''
        pass

    def setZAxisUp(self, rotateView): 
        '''setZAxisUp(self, rotateView)
Arguments:
	[in]	rotateView = bool

This method sets the flag to identify which axis is Up, and
rotates the ground plane around around the X-axis -90 degrees to
get the Z-Up from Y-Up.'''
        pass

    def kSelectComponentMode(self):
        '''This is an enum of MSelectionMode.
Description: Select components.
Value: 1'''
        pass

    def kSelectTemplateMode(self):
        '''This is an enum of MSelectionMode.
Description: Select templates.
Value: 4'''
        pass

    def kSelectRootMode(self):
        '''This is an enum of MSelectionMode.
Description: Select DAG roots.
Value: 2'''
        pass

    def kSelectObjectMode(self):
        '''This is an enum of MSelectionMode.
Description: Select objects.
Value: 0'''
        pass

    def kSelectLeafMode(self):
        '''This is an enum of MSelectionMode.
Description: Select DAG leaves.
Value: 3'''
        pass

    class MSelectionMode:
        '''Non-functional class.  Values for this enum:
        kSelectComponentMode
        kSelectTemplateMode
        kSelectRootMode
        kSelectObjectMode
        kSelectLeafMode
'''
        def __init__(self):
            pass

    def setObjectSelectionMask(self, mask): 
        '''setObjectSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask

Set the object selection mask to the supplied value'''
        pass

    def kWireframeSelectMethod(self):
        '''This is an enum of SelectionMethod.
Description: Select based on the surface of the objects.
Value: 1'''
        pass

    def kSurfaceSelectMethod(self):
        '''This is an enum of SelectionMethod.
Description: Select based on the wireframe of the objects.
Value: 0'''
        pass

    class SelectionMethod:
        '''Non-functional class.  Values for this enum:
        kWireframeSelectMethod
        kSurfaceSelectMethod
'''
        def __init__(self):
            pass

    def viewFrame(self, time): 
        '''viewFrame(self, time)
Arguments:
	[in]	time = double

Sets the global time to the specified time. This function is
optimized for sequential time values that are monotonically
increasing. While one can set the time randomly with this function,
a significant performance hit will be incurred.'''
        pass

    def isSelected(self, object): 
        '''isSelected(self, object) -> bool

Arguments:
	[in]	object = MObject

Determines whether the given object is on the active selection
list.'''
        pass

    def addToModel(self, object, parent): 
        '''addToModel(self, object, parent)
Arguments:
	[in]	object = MObject
	[in]	parent = MObject

This method is used to add new dag objects to the model. If no
parent node is specified, then the node is added under the world.
When a node is added under the world, then a transform node is
automatically created as a parent. This assumes that the node being
added is not already a transform node. This method is only valid
for dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will
be returned.'''
        pass

    def closeErrorLog(self): 
        '''closeErrorLog(self)
This method closes the API error log file. If error logging is
currently enabled this method disables it. The error log is time
and date stamped before it is closed. After the log is closed the
error log path name is reset to the default path name. If the error
log file is already closed, then no action is taken.'''
        pass

    def selectCommand(self, src, listAdjustment): 
        '''selectCommand(self, src, listAdjustment)
Arguments:
	[in]	src = MSelectionList
	[in]	listAdjustment = MGlobal.ListAdjustment

Set the active selection list, by calling the built in Maya
select command. This differs from setActiveSelectionList in that in
this version Maya takes over the selection list you give it and
will be responsible for maintaing the necessary information
required for undo, redo, and journalling.'''
        pass

    def startErrorLogging(self, logPathName): 
        '''startErrorLogging(self, logPathName)
Arguments:
	[in]	logPathName = MString

MapiSuccess( &ReturnStatus );.'''
        pass

    def displayError(self, theError): 
        '''displayError(self, theError)
Arguments:
	[in]	theError = MString

This method is used to display an error in the script
editor.'''
        pass

    def getSelectionListByName(self, name, list): 
        '''getSelectionListByName(self, name, list)
Arguments:
	[in]	name = MString
	[out]	list = MSelectionList

This method fills a selection list with all of the objects that
match a specified name. The name may use the same type of regular
expressions the can be used in MEL commands. For example, the
pattern "pCube*" will match all occurances of objects that begin
their names with "pCube".'''
        pass

    def getLiveList(self, dest): 
        '''getLiveList(self, dest)
Arguments:
	[out]	dest = MSelectionList

Returns a copy of the live list. When a user performs a
"Modify->Make Live" in the user interface the currently selected
objects are added to the live list.'''
        pass

    def selectByName(self, name, listAdjustment): 
        '''selectByName(self, name, listAdjustment)
Arguments:
	[in]	name = MString
	[in]	listAdjustment = MGlobal.ListAdjustment

Puts objects that match the give name on the active selection
list.'''
        pass

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

Returns true if Maya is currently in the middle of an redo.'''
        pass

    def setOptionVarValue(self, name, value): 
        '''setOptionVarValue(self, name, value) -> bool
Returns: Returns:
true

Arguments:
	[in]	name = MString
	[in]	value = MString

This method is used to set the option variable value of type
string'''
        pass

    def miscSelectionMask(self): 
        '''miscSelectionMask(self) -> MSelectionMask

Returns the miscellaneous selection mask.'''
        pass

    def selectFromScreen(self, start_x, start_y, end_x, end_y, listAdjustment, selectMethod): 
        '''selectFromScreen(self, start_x, start_y, end_x, end_y, listAdjustment, selectMethod)
Arguments:
	[in]	start_x = short
	[in]	start_y = short
	[in]	end_x = short
	[in]	end_y = short
	[in]	listAdjustment = MGlobal.ListAdjustment
	[in]	selectMethod = MGlobal.SelectionMethod

Perform marquee type selection on the dag. If an object
intersects the selection rectangle, it is selected according to
listAdjustment.'''
        pass

    def optionVarDoubleValue(self, name, result): 
        '''optionVarDoubleValue(self, name, result) -> double

Arguments:
	[in]	name = MString
	[in]	result = bool

This method is used to get the option variable value of type
double'''
        pass

    def doErrorLogEntry(self, errorLogEntry): 
        '''doErrorLogEntry(self, errorLogEntry)
Arguments:
	[in]	errorLogEntry = MString

Logs an entry in the currently open log file. It is not
necessary for error logging to be enabled, but a log file must be
open. A newline is appended to each log entry.'''
        pass

    def executeCommand(self, command, displayEnabled, undoEnabled, result): 
        '''executeCommand(self, command, displayEnabled, undoEnabled, result)
Arguments:
	[in]	command = MString
	[out]	result = MString
	[in]	displayEnabled = bool
	[in]	undoEnabled = bool

This method is not available in Python.'''
        pass

    def objectSelectionMask(self): 
        '''objectSelectionMask(self) -> MSelectionMask

Returns the object selection mask.'''
        pass

    def setErrorLogPathName(self, logPathName): 
        '''setErrorLogPathName(self, logPathName)
Arguments:
	[in]	logPathName = MString

Closes the current log file if it is open, and then sets the log
path to the given path. If logging is enabled, it remains enabled,
but on the log file speicified by the new path. If logging is
disabled, it remains disabled. Use  startErrorLogging() 
to enable logging to the new file. If the given path name is the
same as the current path name, no action is taken, but an invalid
parameter error is returned.'''
        pass

    def executeCommandStringResult(self, command, displayEnabled, undoEnabled): 
        '''executeCommandStringResult(self, command, displayEnabled, undoEnabled) -> MString
Returns: Returns:
String value returned by command

Arguments:
	[in]	command = MString
	[in]	displayEnabled = bool
	[in]	undoEnabled = bool

Executes a MEL command that returns a string result from the
command engine. Optionally allows display of the command in the
Command Window to be enabled or disabled. Defaults to disabled.
Optionally allows undo for the command to be enabled or disabled.
Defaults to disabled.'''
        pass

    def getActiveSelectionList(self, dest): 
        '''getActiveSelectionList(self, dest)
Arguments:
	[out]	dest = MSelectionList

Returns a copy of the active selection list.'''
        pass

    def setAnimSelectionMask(self, mask): 
        '''setAnimSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask

Set the animation selection mask to the supplied value'''
        pass

    def optionVarIntValue(self, name, result): 
        '''optionVarIntValue(self, name, result) -> int

Arguments:
	[in]	name = MString
	[in]	result = bool

setting & getting option variable values'''
        pass

    def setActiveSelectionList(self, src, listAdjustment): 
        '''setActiveSelectionList(self, src, listAdjustment)
Arguments:
	[in]	src = MSelectionList
	[in]	listAdjustment = MGlobal.ListAdjustment

Set the active selection list. The selection items on the given
list will update the contents of the active selection list as
indicated by the listAdjustment parameter.'''
        pass

    def setComponentSelectionMask(self, mask): 
        '''setComponentSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask

Set the component selection mask to the supplied value'''
        pass

    def mayaState(self): 
        '''mayaState(self) -> MGlobal.MMayaState

Returns an enumerated type specifying the way in which Maya was
invoked.'''
        pass

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

Returns a string describing this version of Maya.'''
        pass

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

Determines the default path name of the error log file. Returns
the null string on failure.'''
        pass

    def clearSelectionList(self): 
        '''clearSelectionList(self)
Removes all items from the active selection list.'''
        pass

    def executeCommandOnIdle(self, command, displayEnabled): 
        '''executeCommandOnIdle(self, command, displayEnabled)
Arguments:
	[in]	command = MString
	[in]	displayEnabled = bool

Sets a MEL command to execute on the next idle event. This is a
thread safe way to execute commands, however, there is no access to
the command results. Optionally allows display of the command in
the Command Window to be enabled or disabled. Defaults to
disabled.'''
        pass

    def setSelectionMode(self, mode): 
        '''setSelectionMode(self, mode)
Arguments:
	[in]	mode = MGlobal.MSelectionMode

Sets the selection mode.'''
        pass

    def removeFromModel(self, object): 
        '''removeFromModel(self, object)
Arguments:
	[in]	object = MObject

Removes the specified dag node from the scene. This method is
only valid for dag nodes. If the specified object is not of type
 MFn::kDagNode  then  MS::kInvalidParameter  will
be returned.'''
        pass

    def unselect(self, object, component): 
        '''unselect(self, object, component)
Arguments:
	[in]	object = MDagPath
	[in]	component = MObject

Remove the given object/components from the active selection
list. If components is null then the object will be unselected,
otherwise the components will be unselected.'''
        pass

    def sourceFile(self, fileName): 
        '''sourceFile(self, fileName)
Arguments:
	[in]	fileName = MString

Causes the MEL command engine to open the named file and execute
the contents of the file as a MEL script. If the provided fileName
is a Unix absolute pathname, then that file is opened. If a
relative pathname is provided, the directories indicated by the
environment variable, MAYA_SCRIPT_PATH, will be searched for a
matching filename.'''
        pass

    def getHiliteList(self, dest): 
        '''getHiliteList(self, dest)
Arguments:
	[out]	dest = MSelectionList

Returns a copy of the hilite list. The hilite list contains all
DAG objects that are hilited for component selection mode. (e.g.
when the user right clicks over a Mesh object and chooses the
"vertex" option the Mesh line drawing changes color and the mesh is
added to the hiliteList.)'''
        pass

    def setDisplayCVs(self, src, state): 
        '''setDisplayCVs(self, src, state)
Arguments:
	[in]	src = MSelectionList
	[in]	state = bool

Controls drawing of control points in the specified selection
list.'''
        pass

    def getFunctionSetList(self, forObject, array): 
        '''getFunctionSetList(self, forObject, array)
Arguments:
	[in]	forObject = MObject
	[out]	array = MStringArray

Gets a list of strings that represent the type of each function
set that will accept this object. The strings match the values in
MFn.h.'''
        pass

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

This method is used to query if the disabling of Stowing
(hiding) and Unstowing (showing) windows is active..'''
        pass

    def displayWarning(self, theWarning): 
        '''displayWarning(self, theWarning)
Arguments:
	[in]	theWarning = MString

This method is used to display a warning in the script
editor.'''
        pass

    def animSelectionMask(self): 
        '''animSelectionMask(self) -> MSelectionMask

Returns the animation selection mask.'''
        pass

    def componentSelectionMask(self): 
        '''componentSelectionMask(self) -> MSelectionMask

Returns the component selection mask.'''
        pass

    def displayInfo(self, theMessage): 
        '''displayInfo(self, theMessage)
Arguments:
	[in]	theMessage = MString

This method is used to display an informational message in the
script editor.'''
        pass

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

Returns true if Maya is currently in the middle of an undo.'''
        pass

    def executePythonCommandStringResult(self, command, displayEnabled, undoEnabled): 
        '''executePythonCommandStringResult(self, command, displayEnabled, undoEnabled) -> MString
Returns: Returns:
String returned from command

Arguments:
	[in]	command = MString
	[in]	displayEnabled = bool
	[in]	undoEnabled = bool

This method is not available in Python.'''
        pass

    def setDisableStow(self, state): 
        '''setDisableStow(self, state)
Arguments:
	[in]	state = bool

This method is used to make the visiblity of all Maya windows
unchangable. If set to true, it disables any attempts to change the
visiblity of any window. In addition, all popup windows will be
supressed.'''
        pass

class MIffFile:
    '''Read file images stored on disk.'''
    def __init__(self):
        pass


    def getChunk(self, chunkTag, byteCount): 
        '''getChunk(self, chunkTag, byteCount) -> void*

Arguments:
	[in]	chunkTag = MIffTag
	[in]	byteCount = *

Opens a chunk for reading. A chunk is a block of unstructured
data with an associated tag.'''
        pass

    def iffGetShort(self, result): 
        '''iffGetShort(self, result)
Arguments:
	[in]	result = short

Grabs a short from the active file.'''
        pass

    def beginGet(self, chunkTag, byteCount): 
        '''beginGet(self, chunkTag, byteCount)
Arguments:
	[in]	chunkTag = MIffTag
	[in]	byteCount = *

Begin grabbing the data.'''
        pass

    def get(self, buf, byteCount): 
        '''get(self, buf, byteCount) -> int

Arguments:
	[in]	buf = void
	[in]	byteCount = unsigned

Attempt to read 'byteCount' bytes from the file into the buffer
pointed to by buf.'''
        pass

    def iffGetFloat(self, result): 
        '''iffGetFloat(self, result)
Arguments:
	[in]	result = float

Grabs a float from the active file.'''
        pass

    def endGet(self): 
        '''endGet(self)
Finish grabbing the data.'''
        pass

    def endReadGroup(self): 
        '''endReadGroup(self)
Closes group currently being read, skipping remaining data
(including nested groups).'''
        pass

    def close(self): 
        '''close(self)
Close the currently open file.'''
        pass

    def beginReadGroup(self, id, type): 
        '''beginReadGroup(self, id, type)
Arguments:
	[in]	id = MIffTag
	[in]	type = MIffTag

Opens a group for reading. A group is composed of several chunks
(sub-groups). Provides the id and type of the current group. Can be
followed by several calls to chunk reading functions or to nested
beginReadGroup(...) calls if needed (depending on the file
structure). The function endReadGroup(...) is used to closed a
group skipping remaining data (including nested groups).'''
        pass

    def open(self, fileName): 
        '''open(self, fileName)
Arguments:
	[in]	fileName = MString

Opens the file for reading.'''
        pass

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

Is the file currently active?'''
        pass

    def iffGetInt(self, result): 
        '''iffGetInt(self, result)
Arguments:
	[in]	result = int

Grabs an integer from the active file.'''
        pass

class MIffTag:
    '''Encapsulates IFF's 4 character block structure.'''
    def __init__(self):
        pass


    kCAT = ''
    '''Defines an unsorted group of FORM, e.g.
images or sounds.'''

    kFOR8 = ''
    '''Eight byte aligned FORM block.'''

    kPROP = ''
    '''Four byte aligned FORM block.'''

    kCAT4 = ''
    '''Four byte aligned CAT block.'''

    kPRO4 = ''
    '''Four byte aligned PROP block.'''

    kLIS8 = ''
    '''Eight byte aligned LIST block.'''

    kPRO8 = ''
    '''Eight byte aligned PROP block.'''

    kLIST = ''
    '''Defines a sorted group of FORM, e.g.
sequence of images.'''

    kFORM = ''
    '''Marks the start of a group of data
blocks.'''

    kLIS4 = ''
    '''Four byte aligned LIST block.'''

    kCAT8 = ''
    '''Eight byte aligned CAT block.'''

    kFOR4 = ''
    '''Four byte aligned FORM block.'''


    def __eq__(self, tag): 
        '''__eq__(self, tag) -> bool

Arguments:
	[in]	tag = MIffTag

'''
        pass

class MImage:
    '''Image manipulation.'''
    def __init__(self):
        pass


    def setFloatPixels(self, inPixelPtr, width, height, channels): 
        '''setFloatPixels(self, inPixelPtr, width, height, channels)
Arguments:
	[in]	inPixelPtr = float
	[in]	width = int
	[in]	height = int
	[in]	channels = int

Set the pointer to the first pixel of the uncompressed pixels
array. This array is tightly packed, of size (width * height *
depth) bytes. For the moment, pixels are always stored in a RGBA
(depth=4 bytes) pixel format.'''
        pass

    def filterExists(self, sourceFormat, targetFormat): 
        '''filterExists(self, sourceFormat, targetFormat) -> bool
Returns: Returns:


true if the filter exists.
false otherwise.

Arguments:
	[in]	sourceFormat = MImage.MImageFilterFormat
	[out]	targetFormat = MImage.MImageFilterFormat

Return whether or not a given source format can be directly
converted to a given target format. See  MImage::filter() 
for more information.'''
        pass

    def getSize(self, width, height): 
        '''getSize(self, width, height)
Arguments:
	[out]	width = int
	[out]	height = int

Get the width and height of the currently opened image.'''
        pass

    def create(self, width, height, channels, type): 
        '''create(self, width, height, channels, type)
Arguments:
	[in]	width = int
	[in]	height = int
	[in]	channels = int
	[in]	type = MImage.MPixelType

Create a new  MImage  object. Allocates memory for an
RGBA array of pixels of the given size. If an object was already in
memory, it is released first.'''
        pass

    def readDepthMap(self, pathname): 
        '''readDepthMap(self, pathname)
Arguments:
	[in]	pathname = MString

Reads the depth map from the specified file and place the result
into the depth map array of this  MImage 
instance.'''
        pass

    def readFromTextureNode(self, fileTextureObject, type): 
        '''readFromTextureNode(self, fileTextureObject, type)
Arguments:
	[in]	fileTextureObject = MObject
	[in]	type = MImage.MPixelType

Attempt to read the content of the given file texture node.
Please note that IFF and SGI are the fastest image file formats for
reading.'''
        pass

    def writeToFile(self, pathname, outputFormat): 
        '''writeToFile(self, pathname, outputFormat)
Arguments:
	[in]	pathname = MString
	[in]	outputFormat = MString

Save the content of this image in a file. By default, the file
is saved in IFF format. Optionally, the file can also be converted
in a variety of image formats.'''
        pass

    def setPixels(self, inPixelPtr, width, height): 
        '''setPixels(self, inPixelPtr, width, height)
Arguments:
	[in]	inPixelPtr = char
	[in]	width = int
	[in]	height = int

Set the pointer to the first pixel of the uncompressed pixels
array. This array is tightly packed, of size (width * height *
depth) bytes. For the moment, pixels are always stored in a RGBA
(depth=4 bytes) pixel format.'''
        pass

    def depthMap(self): 
        '''depthMap(self) -> float*
Returns: Returns:


MS::kFailure - invalid
object, or no depth data exists for this image instance.
MS::kSuccess - depth
buffer successfully returned.

Returns a pointer to the depth data.'''
        pass

    def setRGBA(self, rgbaFormat): 
        '''setRGBA(self, rgbaFormat)
Arguments:
	[in]	rgbaFormat = bool

Sets a flag to indicate that pixel information is in RGBA
sequence or BGRA sequence. Pixel data must have been allocated
before this call is made.'''
        pass

    def readFromFile(self, pathname, type): 
        '''readFromFile(self, pathname, type)
Arguments:
	[in]	pathname = MString
	[in]	type = MImage.MPixelType

Attempt to identify and open the specified image file. Please
note that IFF and SGI are the fastest image file formats for
reading.'''
        pass

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

Returns true if this instance of  MImage 
contains a depth map.'''
        pass

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

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

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

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

    class MImageFilterFormat:
        '''Non-functional class.  Values for this enum:
        kUnknownFormat
        kNormalMapBumpFormat
        kHeightFieldBumpFormat
        kNoFormat
'''
        def __init__(self):
            pass

    def kByte(self):
        '''This is an enum of MPixelType.
Description: One byte per channel, ranging from 0 to 255.
Value: 1'''
        pass

    def kFloat(self):
        '''This is an enum of MPixelType.
Description: One float per channel, ranging from 0.0 to 1.0.
Value: 2'''
        pass

    def kUnknown(self):
        '''This is an enum of MPixelType.
Description: Format not known or invalid.
Value: 0'''
        pass

    class MPixelType:
        '''Non-functional class.  Values for this enum:
        kByte
        kFloat
        kUnknown
'''
        def __init__(self):
            pass

    def setDepthMap(self, depth, width, height): 
        '''setDepthMap(self, depth, width, height)
Arguments:
	[in]	depth = MFloatArray
	[in]	width = unsigned
	[in]	height = unsigned

Specifies the depth map resolution and data. Note, it is
possible for the depth map to be a different resolution from the
color map. This is to support oversampling with image planes. You
cannot save image data to a file if the color map and image maps
are different resolutions.'''
        pass

    def convertPixelFormat(self, format, scale, offset): 
        '''convertPixelFormat(self, format, scale, offset)
Arguments:
	[in]	format = MImage.MPixelType
	[in]	scale = double
	[in]	offset = double

Convert the pixel format used by this image using the specified
parameters.'''
        pass

    def getDepthMapSize(self, width, height): 
        '''getDepthMapSize(self, width, height)
Arguments:
	[out]	width = int
	[out]	height = int

Returns the size of the depth map buffer. Note, depth maps can
differ in resolution from the color map. This is mainly for
oversampling support in image planes. In all other cases, you
should insure that depth size matches the color buffer size. You
cannot write out an image where the depth map and image map has
different resolutions.'''
        pass

    def verticalFlip(self): 
        '''verticalFlip(self)
Flips the image vertically.   Reprocessed example '''
        pass

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

Query flag which indicates whether the pixel information is in
RGBA sequence or BGRA sequence. If no pixel data exists, then false
will be returned.'''
        pass

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

Returns a pointer to the first pixel of the uncompressed pixels
array. This array is tightly packed, of size (width * height *
depth) bytes. For the moment, pixels are always stored in a RGBA
(depth=4 bytes) pixel format.'''
        pass

    def resize(self, width, height, preserveAspectRatio): 
        '''resize(self, width, height, preserveAspectRatio)
Arguments:
	[in]	width = int
	[in]	height = int
	[in]	preserveAspectRatio = bool

Resize the currently opened image to the specified dimension, or
to the closest width/height that is preserves the original aspect
ratio.'''
        pass

    def floatPixels(self): 
        '''floatPixels(self) -> float*

Returns a pointer to the first pixel of the uncompressed pixels
array. This array is tightly packed, of size (width * height *
depth * sizeof( float)) bytes.'''
        pass

    def pixelType(self): 
        '''pixelType(self) -> MImage.MPixelType

Get the current pixel format of the image.'''
        pass

    def filter(self, sourceFormat, targetFormat, scale, offset): 
        '''filter(self, sourceFormat, targetFormat, scale, offset)
Arguments:
	[in]	sourceFormat = MImage.MImageFilterFormat
	[in]	targetFormat = MImage.MImageFilterFormat
	[in]	scale = double
	[in]	offset = double

Modify the content of the image by applying a filter. The
dimension of the image remains the same; only the RGBA components
get affected.'''
        pass

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

Get the color depth (in bytes) of the currently opened
image.'''
        pass

    def writeToFileWithDepth(self, pathname, outputFormat, writeDepth): 
        '''writeToFileWithDepth(self, pathname, outputFormat, writeDepth)
Arguments:
	[in]	pathname = MString
	[in]	outputFormat = MString
	[in]	writeDepth = bool

Save the content of this image in a file. By default, the file
is saved in IFF format. Optionally, the file can also be converted
in a variety of image formats. If the writeDepth parameter is true
then any depth information stored in  MImage  will be
written to file.'''
        pass

    def release(self): 
        '''release(self)
Release the current image. If there is no current image, the
call is ignored. An image is always released automatically during
destruction, so generally there is no need to call this function
manually.'''
        pass

class MImageFileInfo:
    '''Image manipulation.'''
    def __init__(self):
        pass


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

Query whether this image contains alpha information.'''
        pass

    def pixelType(self): 
        '''pixelType(self) -> MImage.MPixelType

Get the native pixel format of this image file.'''
        pass

    def hardwareType(self): 
        '''hardwareType(self) -> MImageFileInfo.MHwTextureType

Get the hardware texture type of this image file, describing
whether this image contains a 2D texture, a cubemap, etc.'''
        pass

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

Get the height in pixels of this image file.'''
        pass

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

Get the number of channels in this image file.'''
        pass

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

Get the width in pixels of this image file.'''
        pass

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

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

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

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

    class MImageType:
        '''Non-functional class.  Values for this enum:
        kImageTypeBump
        kImageTypeColor
        kImageTypeUnknown
        kImageTypeNormal
'''
        def __init__(self):
            pass

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

Query whether this image contains or can generate mipmap
information.'''
        pass

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

Get the number of images in this image file.'''
        pass

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

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

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

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

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

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

    class MHwTextureType:
        '''Non-functional class.  Values for this enum:
        kHwTexture1D
        kHwTextureRectangle
        kHwTexture3D
        kHwTexture2D
        kHwTextureCubeMap
        kHwTextureUnknown
'''
        def __init__(self):
            pass

    def imageType(self): 
        '''imageType(self) -> MImageFileInfo.MImageType

Query the type of information in this image file (e.g. is it a
color map, a normal map, etc). Most image file formats do not
contain this information, meaning this will be left as
kImageTypeUnknown.'''
        pass

class MIntArray:
    '''Array of integers data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int

Sets the value of the indicated element to the indicated
value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = int

Copy the elements of the array into the given C++ array of ints.
No checking is done to ensure that the destination C++ array of
ints is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MIntArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = int

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MIteratorType:
    '''MIteratorType class.'''
    def __init__(self):
        pass


    def getFilterType(self): 
        '''getFilterType(self) -> MFn.Type
Returns: Returns:
The filter type.

Returns the type of filter.'''
        pass

    def kMPlugObject(self):
        '''This is an enum of objFilterType.
Description: This is to indicate that the root of the iterator has to be
reset to an
Value: 2'''
        pass

    def kMObject(self):
        '''This is an enum of objFilterType.
Description: This is to indicate that the root of the iterator has to be
reset to an
Value: 0'''
        pass

    def kMDagPathObject(self):
        '''This is an enum of objFilterType.
Description: This is to indicate that the root of the iterator has to be
reset to an
Value: 1'''
        pass

    class objFilterType:
        '''Non-functional class.  Values for this enum:
        kMPlugObject
        kMObject
        kMDagPathObject
'''
        def __init__(self):
            pass

    def setFilterType(self, type): 
        '''setFilterType(self, type)
Arguments:
	[in]	type = MFn.Type

Sets the filter type to be used in the iterator. See  MFn::Type  for the list of filter
types that can be set.'''
        pass

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

Returns whether the we are using a single filter on the iterator
or a filter list.'''
        pass

    def getFilterList(self, listOfFilters): 
        '''getFilterList(self, listOfFilters)
Arguments:
	[out]	listOfFilters = MIntArray

Gets the list of filters.'''
        pass

    def setFilterList(self, listOfFilters): 
        '''setFilterList(self, listOfFilters)
Arguments:
	[in]	listOfFilters = MIntArray

Sets the filter list. The types of filters to be traversed in
the iterator is added to an array and then passed in to this
function. This also enables filter list usage on iterators, as
opposed to single filter.'''
        pass

    def setObjectType(self, objFilterType): 
        '''setObjectType(self, objFilterType)
Arguments:
	[in]	objFilterType = objFilterType

Sets the object type. This function should be used only when we
want to reset the iterator root. Iterator root can be reset to
either an  MObject , an
 MDagPath  or to an  MPlug . For each of
this, there is a corresponding enum value, which has to be used as
an argument to this function.'''
        pass

    def getObjectType(self): 
        '''getObjectType(self) -> MIteratorType.objFilterType
Returns: Returns:
The object type.

Returns the object type.'''
        pass

class MItCurveCV:
    '''Iterator for NURBS curve CVs.'''
    def __init__(self):
        pass


    def reset(self, curve, component): 
        '''reset(self, curve, component)
Arguments:
	[in]	curve = MDagPath
	[in]	component = MObject

Reset the iterator to the specified curve and component. The
component is a group of CVs belonging to the specified curve. The
component defaults to  MObject::kNullObj .
If a component is not given then the iterator will be reset for the
whole curve.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: Returns:
The index of the current CV

This method returns the index of the current CV in the CV array
for this curve.'''
        pass

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

This method determines if the shape was created with
history.'''
        pass

    def updateCurve(self): 
        '''updateCurve(self)
This method is used to signal the curve that it has been changed
and needs to redraw itself.'''
        pass

    def translateBy(self, vec, space): 
        '''translateBy(self, vec, space)
Arguments:
	[in]	vec = MVector
	[in]	space = MSpace.Space

Translates the current CV by the amount sepcified in
 vec .'''
        pass

    def next(self): 
        '''next(self)
Advance to the next CV in the iteration. If the iterator is
already at the last CV then this method has no effect. Use
 isDone  to determine if the iterator is at the last CV.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
A handle to the CV requested

This method returns the current CV as an  MObject .'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: Returns:
Status code

Arguments:
	[in]	space = MSpace.Space

Return the position of the current CV.'''
        pass

    def setPosition(self, pt, space): 
        '''setPosition(self, pt, space)
Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space

Set the position of the current CV to the specified point.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Boolean value: true if there are no more CVs to iterate
on, false otherwise.

Returns  true  if the iteration is finished, i.e. there are
no more CVs to iterate on.'''
        pass

class MItDag:
    '''DAG Iterator.'''
    def __init__(self):
        pass


    def reset(self, dagInfoObject, object, path, type): 
        '''reset(self, dagInfoObject, object, path, type)
Arguments:
	[in]	dagInfoObject = MIteratorType
	[in]	object = MObject
	[in]	path = MDagPath
	[in]	type = MItDag.TraversalType

Resets root, type and filter list of the iterator. This method
is usefull when a node is instanced and a DAG path is necessary to
specify which instance should be the root of the traversal.'''
        pass

    def fullPathName(self): 
        '''fullPathName(self) -> MString
Returns: Returns:
The full path name

Return a string representing the full path from the root of the
dag to this object.'''
        pass

    def prune(self): 
        '''prune(self)
Prunes iteration tree at current node.'''
        pass

    def traverseUnderWorld(self, flag): 
        '''traverseUnderWorld(self, flag)
Arguments:
	[in]	flag = bool

Specifies whether underworld traversal is turned on. The default
is off.'''
        pass

    def isInstanced(self, indirect): 
        '''isInstanced(self, indirect) -> bool
Returns: Returns:


true = Node is instanced (directly or indirectly according to
indirect instance flag)
false = Node is not instanced (directly or indirectly according
to indirect instance flag)

Arguments:
	[in]	indirect = bool

Determines whether the current item (DAG node) in the iteration
is directly or indirectly instanced.'''
        pass

    def getType(self): 
        '''getType(self) -> MItDag.TraversalType
Returns: Returns:


kDepthFirst Recursively visits grandchildren of each
child node
kBreadthFirst Recursively visits each child/parent node
before any grandchild/grandparent nodes

Returns the direction of the traversal.'''
        pass

    def partialPathName(self): 
        '''partialPathName(self) -> MString
Returns: Returns:
The partial path name

Return a string representing the partial path from the root of
the dag to this object.'''
        pass

    def getPath(self, path): 
        '''getPath(self, path)
Arguments:
	[out]	path = MDagPath

Determines a DAG Path to the current item in the iteration.'''
        pass

    def next(self): 
        '''next(self)
Moves to the next node matching the filter in the graph.'''
        pass

    def depth(self): 
        '''depth(self) -> int
Returns: Returns:
Depth of the current node

Returns the height or depth of the current node in the DAG
relative to the root node. The root node has a depth of zero.'''
        pass

    def instanceCount(self, total): 
        '''instanceCount(self, total) -> int

Arguments:
	[in]	total = bool

Determines the number of times the current item (DAG node) in
the iteration is instanced.'''
        pass

    def willTraverseUnderWorld(self): 
        '''willTraverseUnderWorld(self) -> bool
Returns: Returns:
Boolean: true if underworld traversal is on,
false otherwise.

Returns true if this iterator will traverse into underworld
items.'''
        pass

    def getAllPaths(self, paths): 
        '''getAllPaths(self, paths)
Arguments:
	[out]	paths = MDagPathArray

Determines all DAG Paths to current item in the iteration.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
Pointer to the DAG node. Null pointer indicates failure.

Retrieves DAG node to which the iterator points.'''
        pass

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

    def kBreadthFirst(self):
        '''This is an enum of TraversalType.
Description: Visit a node's siblings before moving on to its children.
Value: 2'''
        pass

    def kDepthFirst(self):
        '''This is an enum of TraversalType.
Description: Visit a node's children before moving on to its siblings.
Value: 1'''
        pass

    class TraversalType:
        '''Non-functional class.  Values for this enum:
        kInvalidType
        kBreadthFirst
        kDepthFirst
'''
        def __init__(self):
            pass

    def root(self): 
        '''root(self) -> MObject
Returns: Returns:
Root of the traversal

Returns the root (start node) of the current traversal. The
constructor sets the root of traversal to the world node. The root
can be changed by the  reset() 
method.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Boolean value: true when done, false
otherwise.

Indicates end of iteration path.'''
        pass

class MItDependencyGraph:
    '''Dependency Graph Iterator.'''
    def __init__(self):
        pass


    def toggleDirection(self): 
        '''toggleDirection(self)
Toggles the direction of the iteration. Resets the root of the
iteration to the current node or plug depending on the level of
iteration. Clears iterator path data. If a valid filter is enabled,
the iterator automatically advances to the next node that matches
the filter. If no matching node is found the status is failure
(MFn::kFailure). No other iterator parameters are affected.'''
        pass

    def rootPlug(self): 
        '''rootPlug(self) -> MPlug
Returns: Returns:
The root plug

Retrieves the root plug of the iteration.'''
        pass

    def getNodePath(self, path): 
        '''getNodePath(self, path)
Arguments:
	[out]	path = MObjectArray

Retrieves the direct path from the current node to the root
node. Path does not include the current node. State of the provided
array is undefined if this method fails.'''
        pass

    def currentTraversal(self): 
        '''currentTraversal(self) -> MItDependencyGraph.Traversal
Returns: Returns:


MItDependencyGraph::kDepthFirst
Traversal is depth first
MItDependencyGraph::kBreadthFirst
Traversal is breadth first

Reports the traversal mode of the iteration through the
graph.'''
        pass

    def previousPlug(self): 
        '''previousPlug(self) -> MPlug
Returns: Returns:


Current plug

Retrieves the previous plug of the iteration. Results in a null
plug on failure. Null plug may also indicate that the current plug
is the root plug.'''
        pass

    def currentDirection(self): 
        '''currentDirection(self) -> MItDependencyGraph.Direction
Returns: Returns:


MItDependencyGraph::kDownstream
Direction is downstream
MItDependencyGraph::kDownstream
Direction is upstream

Reports the direction of the iteration through the graph.'''
        pass

    def resetTo(self, rootNode, rootPlug, infoObject, direction, traversal, level): 
        '''resetTo(self, rootNode, rootPlug, infoObject, direction, traversal, level)
Arguments:
	[in]	rootNode = MObject
	[in]	rootPlug = MPlug
	[in]	infoObject = MIteratorType
	[in]	direction = MItDependencyGraph.Direction
	[in]	traversal = MItDependencyGraph.Traversal
	[in]	level = MItDependencyGraph.Level

Clears iterator data and re-initializes the iterator. The filter
list is reset to the new list specified thro'  MIteratorType  object. If a valid filter
is enabled, the iterator automatically advances to the next node
after the root node/plug that matches the filter. If no matching
node is found the status is failure (MFn::kFailure).'''
        pass

    def next(self): 
        '''next(self)
Iterates to the next node or plug in accordance with the
direction, traversal, level and filter. If a valid filter is set,
the iterator only visits those nodes that match the filter. When
filtering is enabled nodes that have unknown type are treated as
non-matching nodes. With filtering disabled, iteration to a node
with an unknown type is treated as a failure. An attempt to iterate
when there is nothing left to iterate over results in failure.'''
        pass

    def currentFilter(self): 
        '''currentFilter(self) -> MFn.Type
Returns: Returns:
The current node type filter

Retrieves the current node type filter.'''
        pass

    def kDownstream(self):
        '''This is an enum of Direction.
Description: From source to destination.
Value: 0'''
        pass

    def kUpstream(self):
        '''This is an enum of Direction.
Description: From destination to source.
Value: 1'''
        pass

    class Direction:
        '''Non-functional class.  Values for this enum:
        kDownstream
        kUpstream
'''
        def __init__(self):
            pass

    def getPlugPath(self, path): 
        '''getPlugPath(self, path)
Arguments:
	[out]	path = MPlugArray

Retrieves the direct path from the current plug to the root
plug. Path does not include the current plug. State of the provided
array is undefined if this method fails.'''
        pass

    def isPruningOnFilter(self): 
        '''isPruningOnFilter(self) -> bool
Returns: Returns:
Bool: true if pruning is enabled, false
otherwise.

Tests whether or not the iteration path is pruned automatically
at nodes or plugs which do not match the filter.'''
        pass

    def enablePruningOnFilter(self): 
        '''enablePruningOnFilter(self)
Enables automatic pruning of iteration path at nodes or plugs
which do not match the filter.'''
        pass

    def kBreadthFirst(self):
        '''This is an enum of Traversal.
Description: Equidistant from root first.
Value: 1'''
        pass

    def kDepthFirst(self):
        '''This is an enum of Traversal.
Description: Away from root first.
Value: 0'''
        pass

    class Traversal:
        '''Non-functional class.  Values for this enum:
        kBreadthFirst
        kDepthFirst
'''
        def __init__(self):
            pass

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


true Traversal is depth first (MItDependencyGraph::kDepthFirst)
false Traversal is breadth first (MItDependencyGraph::kBreadthFirst)

Tests whether or not the iteration is proceeding depth first
(away from the root of the iteration) in the DG.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
Current node

Retrieves the current node of the iteration. Results in a null
object on failure or if the node is of a unrecognized type.'''
        pass

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


true Iteration is done
false Iteration is not done

Indicates whether or not all nodes or plugs have been iterated
over in accordance with the direction, traversal, level and filter.
If a valid filter is set, the iterator only visits those nodes that
match the filter.'''
        pass

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


true Unknown type
false Type is known or iterator is done or failure
encountered

Indicates whether or not the current node has an unrecognised
type. This is useful if an unexpected failure is encountered in the
 
next()  or  thisNode()  methods.'''
        pass

    def thisPlug(self): 
        '''thisPlug(self) -> MPlug
Returns: Returns:
Current plug

Retrieves the current plug of the iteration. Results in a null
plug on failure.'''
        pass

    def currentLevel(self): 
        '''currentLevel(self) -> MItDependencyGraph.Level
Returns: Returns:


MItDependencyGraph::kNodeLevel
Level is node level
MItDependencyGraph::kPlugLevel
Level is plug level

Reports the level of the iteration through the graph.'''
        pass

    def getNodesVisited(self, nodes): 
        '''getNodesVisited(self, nodes)
Arguments:
	[out]	nodes = MObjectArray

Retrieves all nodes visited during the iteration. State of the
provided array is undefined if this method fails.'''
        pass

    def kNodeLevel(self):
        '''This is an enum of Level.
Description: Visit each Node at most once.
Value: 0'''
        pass

    def kPlugLevel(self):
        '''This is an enum of Level.
Description: Visit each Plug at most once.
Value: 1'''
        pass

    class Level:
        '''Non-functional class.  Values for this enum:
        kNodeLevel
        kPlugLevel
'''
        def __init__(self):
            pass

    def disablePruningOnFilter(self): 
        '''disablePruningOnFilter(self)
Disables automatic pruning of iteration path at nodes or plugs
which do not match the filter.'''
        pass

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


true Traversing of world-space attributes is
enabled.
false Traversing of world-space attributes is
disabled.

Tests whether the iterator is set to traverse world-space
attribute dependencies.'''
        pass

    def getPlugsVisited(self, plugs): 
        '''getPlugsVisited(self, plugs)
Arguments:
	[out]	plugs = MPlugArray

Retrieves all plugs visited during the iteration. State of the
provided array is undefined if this method fails.'''
        pass

    def toggleTraversal(self): 
        '''toggleTraversal(self)
Toggles the traversal of the iteration. Resets the root of the
iteration to the current node or plug depending on the level of
iteration. Clears iterator path data. If a valid filter is enabled,
the iterator automatically advances to the next node that matches
the filter. If no matching node is found the status is failure
(MFn::kFailure). No other iterator parameters are affected.'''
        pass

    def resetFilter(self): 
        '''resetFilter(self)
Resets the node or plug filter to default,  MFn::kInvalid  (filter disabled). Disables
pruning on the filter (default). Resets the iterator.'''
        pass

    def setCurrentFilter(self, filter): 
        '''setCurrentFilter(self, filter)
Arguments:
	[in]	filter = MFn.Type

Sets the node or plug filter. Plug filtering is based on the
type of the corresponding Attribute. Defaults to disabled
( MFn::kInvalid ). If a valid filter is specified,
the iterator automatically advances to the next node that matches
the filter. If no matching node status is failure
(MFn::kFailure).'''
        pass

    def setTraversalOverWorldSpaceDependents(self, val): 
        '''setTraversalOverWorldSpaceDependents(self, val)
Arguments:
	[in]	val = bool

When set to true, the iterator will include world-space
attribute dependencies in its traversal. For example, say there is
an animation curve attached to the translateX attribute on a
transform, and an upstream iterator starts at the worldMatrix
attribute. If world-space traversal is enabled, the iterator will
get to the animation curve. Note however that even when world-space
traversal is enabled, the iterator will only iterate to connected
nodes. It does not iterate up and down through the dag
hierarchy.'''
        pass

    def reset(self): 
        '''reset(self)
Clears iterator data and resets the iterator to the root node or
plug. If a valid filter is enabled, the iterator automatically
advances to the next node after the root node that matches the
filter. If no matching node is found the status is failure
(MFn::kFailure).'''
        pass

    def prune(self): 
        '''prune(self)
Prunes the search path at the current plug. Iterator will not
visit any of the plugs connected to the pruned plug.'''
        pass

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


true Direction is downstream (MItDependencyGraph::kDownstream)
false Direction is upstream (MItDependencyGraph::kUpstream)

Tests whether or not the iteration is moving downstream (in the
direction of data flow) in the DG.'''
        pass

    def rootNode(self): 
        '''rootNode(self) -> MObject
Returns: Returns:
The root node

Retrieves the root node of the iteration.'''
        pass

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


true node level (MItDependencyGraph::kNodeLevel)
false plug level (MItDependencyGraph::kPlugLevel)

Tests whether or not the iteration is at the node level of
detail (every node is visited only once) in the DG.'''
        pass

    def toggleLevel(self): 
        '''toggleLevel(self)
Toggles the level of the iteration. Resets the root of the
iteration to the current node or plug depending on the level of
iteration. Clears iterator path data. If a valid filter is enabled,
the iterator automatically advances to the next node that matches
the filter. If no matching node is found the status is failure
(MFn::kFailure). No other iterator parameters are affected.'''
        pass

class MItDependencyNodes:
    '''Dependency Node iterator.'''
    def __init__(self):
        pass


    def reset(self, infoObject): 
        '''reset(self, infoObject)
Arguments:
	[in]	infoObject = MIteratorType

Resets the iterator and reinitializes the filter list. The
filter list is specified through  MIteratorType  object.'''
        pass

    def thisNode(self): 
        '''thisNode(self) -> MObject
Returns: Returns:
The dependency node. A null MObject indicates failure.

Retrieves the dependency node to which the iterator points.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Bool: true if the iteration is done, false
otherwise

Indicates end of the iteration.'''
        pass

    def next(self): 
        '''next(self)
Moves to the next node matching the filter. If the filter is set
to kInvalid, this method advances to the next DG node without doing
any filtering.'''
        pass

class MItGeometry:
    '''Iterator class for geometry data.'''
    def __init__(self):
        pass


    def count(self): 
        '''count(self) -> int
Returns: Returns:
The number of items that will be iterated

Return the number of items in this iteration. This number will
always be at least as large as the number of items, however in some
cases it may be larger. It is useful if allocating space in an
array to hold the results, since it will always be of sufficient
size. If the exact number of items is required, use the exactCount
method instead. The exactCount method is however significantly
slower than this method.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: Returns:
The index of the current point/CV/vertex.

This method returns the index of the current point/CV/vertex
component in the iteration.'''
        pass

    def exactCount(self): 
        '''exactCount(self) -> int
Returns: Returns:
The number of items that will be iterated

Return the exact number of items in this iteration. This method
is significantly slower than the  count() 
method, so use if only if the precise number is required.'''
        pass

    def weight(self): 
        '''weight(self) -> MWeight
Returns: Returns:
The current component's weight

Return the weight of the current point/CV/vertex component.'''
        pass

    def next(self): 
        '''next(self)
Advance to the next component in the iteration. If the iterator
is already at the last component then this method has no effect.
Use  isDone  to determine if the iterator is at the last
component.'''
        pass

    def reset(self): 
        '''reset(self)
Reset the iterator to the first component.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
The current component in the iteration.

This method returns the current component in the iteration.'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: Returns:
Status code

Arguments:
	[in]	space = MSpace.Space

Return the position of the current point/CV/vertex
component.'''
        pass

    def setPosition(self, pt, space): 
        '''setPosition(self, pt, space)
Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space

Set the position of the current point/CV/vertex.'''
        pass

    def setAllPositions(self, pt, space): 
        '''setAllPositions(self, pt, space)
Arguments:
	[in]	pt = MPointArray
	[in]	space = MSpace.Space

Set the position of all the points/CVs/vertices at once. This
operation is faster than using the iterator to set values one by
one, but uses more memory as it requires an array to hold all the
values to be set.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Bool true if There are no more components to iterate on,
false otherwise.

Returns  true  if the iteration is finished, i.e. there are
no more components to iterate on.'''
        pass

    def allPositions(self, space, points): 
        '''allPositions(self, space, points)
Arguments:
	[out]	points = MPointArray
	[in]	space = MSpace.Space

Return the position of all the points/CVs/vertices. This
operation is faster than using the iterator to get values one by
one, but uses more memory as it requires an array to hold all the
values to be returned.'''
        pass

class MItInstancer:
    '''Particle iterator.'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)
Moves the iterator to the first dag-path to the first
replaced-particle in the scene. If none exist, then  isDone() 
will be immediately  true .'''
        pass

    def matrix(self): 
        '''matrix(self) -> MMatrix

Returns the transformation matrix represented by the current
path. If there is no such path, identity matrix will be
returned.'''
        pass

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

Returns a unique identifier for the current particle.
Collectively, this id together with the instancer id and the path
id uniquely identify a "replaced particle".'''
        pass

    def instancerPath(self): 
        '''instancerPath(self) -> MDagPath

Returns the full DAG path to the instancer that generated the
current particle instance.'''
        pass

    def nextParticle(self): 
        '''nextParticle(self)
Advances the iterator to the next replaced-particle in the
scene, skipping over any remaining dag-paths associated with the
current replaced-particle.'''
        pass

    def next(self): 
        '''next(self)
Advances the iterator to the next replaced-particle dag-path in
the scene. Calling  reset() ,
then repeatedly calling this method until  isDone() 
becomes  true  is equivalent to the following loop
structure:'''
        pass

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

Returns the current instancer node as an  MObject .'''
        pass

    def nextInstancer(self): 
        '''nextInstancer(self)
Advances the iterator to the next instancer in the scene,
skipping over any remaining particles associated with the current
instancer.'''
        pass

    def instancerId(self): 
        '''instancerId(self) -> MUintPtrSz

Returns a unique identifier for the current instancer.
Collectively, this id together with the particle id and the path id
uniquely identify a "replaced particle".'''
        pass

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

Returns a unique identifier for the current path. Collectively,
this id together with the instancer id and the particle id uniquely
identify a "replaced particle".'''
        pass

    def path(self): 
        '''path(self) -> MDagPath

Returns the replaced-particle dag-path which the iterator is
currently pointing to. Each path is to a shape. If the particle is
replaced by a shape directly then there will be only one path per
particle. If a particle is replaced by a transform with many child
shapes then each one of those shapes will have a path. Amongst the
paths corresponding to a given particle there may be multiple paths
to multiple shapes. If there is no such path, a null path will be
returned.'''
        pass

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

Returns  true  if the iteration is finished, i.e. there are
no more dag-paths to replaced-particles in the scene.'''
        pass

class MItMeshEdge:
    '''Polygon edge iterator.'''
    def __init__(self):
        pass


    def onBoundary(self): 
        '''onBoundary(self) -> bool
Returns: Returns:
Boolean value: true if it's a border edge, false
otherwise.

This method checks to see if the current edge is a border
edge.'''
        pass

    def connectedToEdge(self, index): 
        '''connectedToEdge(self, index) -> bool

Arguments:
	[in]	index = int

This method determines whether the given edge is connected to
the current edge'''
        pass

    def point(self, index, space): 
        '''point(self, index, space) -> MPoint
Returns: Returns:
The position of the edge vertex for the given index

Arguments:
	[in]	index = int
	[in]	space = MSpace.Space

Return the position of the specified vertex of the current
edge.'''
        pass

    def getConnectedFaces(self, faces): 
        '''getConnectedFaces(self, faces) -> int

Arguments:
	[in]	faces = MIntArray

This method returns a list of faces (with 1 or 2 faces)
connected to teh current edge.'''
        pass

    def setSmoothing(self, smooth): 
        '''setSmoothing(self, smooth)
Arguments:
	[in]	smooth = bool

This method sets the current edge to be hard or smooth (soft).
The  cleanupSmoothing  method is no longer required to be
called after setSmoothing in Maya3.0 and later versions.'''
        pass

    def setIndex(self, index, prevIndex): 
        '''setIndex(self, index, prevIndex)
Arguments:
	[in]	index = int
	[in]	prevIndex = int

This method sets the index of the current edge to be accessed.
The current edge will no longer be in sync with any previous
iteration. two vertices.'''
        pass

    def connectedToFace(self, index): 
        '''connectedToFace(self, index) -> bool

Arguments:
	[in]	index = int

This method determines whether the given face contains the
current edge'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)
Reset the geom pointer in the  MItMeshEdge . If you're using  MFnMesh  to update Normals or
Color per vertex while iterating, you must call geomChanged on the
iterator immediately after the  MFnMesh  call to make sure
that your geometry is up to date. A crash may result if this method
is not called.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: Returns:
The index of the current edge in the iteration

This method returns the index of the current edge in the
iteration.'''
        pass

    def getLength(self, space, length): 
        '''getLength(self, space, length)
Arguments:
	[out]	length = double
	[in]	space = MSpace.Space

This method returns the length of the current edge.'''
        pass

    def next(self): 
        '''next(self)
Advance to the next edge in the iteration.'''
        pass

    def numConnectedEdges(self, edgeCount): 
        '''numConnectedEdges(self, edgeCount)
Arguments:
	[in]	edgeCount = int

This method returns the number of edges connected to the current
edge.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
The current edge in the interation

Get the current edge in the iteration as a component.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Boolean value: true All edges have been traversed,
false otherwise.

Indicates if all of the edges have been traversed yet.'''
        pass

    def count(self): 
        '''count(self) -> int
Returns: Returns:
The number of edges in the iteration

Return the number of edges in this iteration.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)
Signal that this polygonal surface has changed and needs to
redraw itself.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject

Reset the iterator to the first edge in the supplied mesh. Uses
the edges constrained by the given component. If component is null
then the iteration will be for all edges in the given polygon.'''
        pass

    def center(self, space): 
        '''center(self, space) -> MPoint

Arguments:
	[in]	space = MSpace.Space

Returns the center of the current edge.'''
        pass

    def setPoint(self, point, index, space): 
        '''setPoint(self, point, index, space)
Arguments:
	[in]	point = MPoint
	[in]	index = int
	[in]	space = MSpace.Space

Set the specified vertex of the current edge to the given
value.'''
        pass

    def getConnectedEdges(self, edges): 
        '''getConnectedEdges(self, edges) -> int

Arguments:
	[in]	edges = MIntArray

This method returns a list of edges connected to the current
edge.'''
        pass

    def isSmooth(self): 
        '''isSmooth(self) -> bool
Returns: Returns:
Boolean value: true if the edge is smooth (soft),
false if the edge is hard.

This method determines if the current edge in the iteration is
smooth (soft).'''
        pass

    def numConnectedFaces(self, faceCount): 
        '''numConnectedFaces(self, faceCount)
Arguments:
	[out]	faceCount = int

This method returns the number of faces (1 or 2 ) connected to
the current edge.'''
        pass

class MItMeshFaceVertex:
    '''Face vertex iterator.'''
    def __init__(self):
        pass


    def faceVertId(self): 
        '''faceVertId(self) -> int
Returns: Returns:
The relative index of the current vertex.

Returns the relative index of the vertex within the current
face. This index together with the faceId can be used for a fast
access to get various info stored per vertex (normals, uvs,
colors).'''
        pass

    def getTangent(self, space, uvSet): 
        '''getTangent(self, space, uvSet) -> MVector

Arguments:
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return the face vertex tangent associated with the given UV set.
The tangent is defined as the surface tangent of the polygon
running in the U direction.'''
        pass

    def setIndex(self, faceIndex, faceVertIndex, prevFaceId, prevVertId): 
        '''setIndex(self, faceIndex, faceVertIndex, prevFaceId, prevVertId)
Arguments:
	[in]	faceIndex = int
	[in]	faceVertIndex = int
	[in]	prevFaceId = int
	[in]	prevVertId = int

This method sets the index of the current face vertex to be
accessed. The current face vertex will no longer be in sync with
any previous iteration.'''
        pass

    def getUVIndex(self, uvSet, index, u, v): 
        '''getUVIndex(self, uvSet, index, u, v)
Arguments:
	[out]	index = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString

Return the index of the texture coordinate for the current face
vertex. This index refers to an element of the texture coordinate
array for the polygonal object returned by  MFnMesh::getUVs .'''
        pass

    def hasUVs(self, uvSet): 
        '''hasUVs(self, uvSet) -> bool
Returns: Returns:
Boolean value: true if the face vertex has UV's mapped,
false otherwise.

Arguments:
	[in]	uvSet = MString

Does this face vertex has UV's mapped or not in a given uv
set.'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)
Reset the geom pointer in the  MItMeshFaceVertex .'''
        pass

    def getBinormal(self, space, uvSet): 
        '''getBinormal(self, space, uvSet) -> MVector

Arguments:
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Return the face vertex binormal associated with the UV set.'''
        pass

    def getColorIndex(self, colorSetName, colorIndex): 
        '''getColorIndex(self, colorSetName, colorIndex)
Arguments:
	[out]	colorIndex = int
	[in]	colorSetName = MString

Return a color index of the current face vertex.'''
        pass

    def next(self): 
        '''next(self)
Advance to the next face vertext in the iteration.'''
        pass

    def normalId(self): 
        '''normalId(self) -> int
Returns: Returns:
The index of the normal for the current vertex

Returns the normal index for the specified vertex. This index
refers to an element in the normal array returned by  MFnMesh::getNormals .
These normals are per-polygon per-vertex normals. See the  MFnMesh  description for more
information on normals.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
An MObject
containing the double index.

Returns the double componet index of the vertex and face.'''
        pass

    def faceId(self): 
        '''faceId(self) -> int
Returns: Returns:
The index of the current face.

Returns the current face index.'''
        pass

    def vertId(self): 
        '''vertId(self) -> int
Returns: Returns:
The index of the current face vertex.

Returns the index of the current face vertex.'''
        pass

    def tangentId(self): 
        '''tangentId(self) -> int
Returns: Returns:
The index of the tangnet for the current vertex

Returns the tangent (or binormal) index for the specified
vertex. This index refers to an element in the normal array
returned by  MFnMesh::getTangents .
These tangent or binormals are per-polygon per-vertex. See the
 MFnMesh  description for more
information on tangents and binormals.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Boolean value: true All face vertices have been
traversed, false otherwise.

Indicates if all of the face vertices have been traversed.'''
        pass

    def getColor(self, colorSetName, color): 
        '''getColor(self, colorSetName, color)
Arguments:
	[out]	color = MColor
	[in]	colorSetName = MString

Return a color of the current face vertex.'''
        pass

    def getUV(self, uvSet, uvPoint): 
        '''getUV(self, uvSet, uvPoint)
Arguments:
	[out]	uvPoint = float2
	[in]	uvSet = MString

Return the texture coordinate for the current face vertex.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject

Reset the iterator with the given surface and component. If
component is null then the iteration will be for all face vertices
in the given surface.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)
Signal that this polygonal surface has changed and needs to
redraw itself.'''
        pass

    def getNormal(self, space, normal): 
        '''getNormal(self, space, normal)
Arguments:
	[out]	normal = MVector
	[in]	space = MSpace.Space

Return the face vertex normal.'''
        pass

    def hasColor(self): 
        '''hasColor(self) -> bool
Returns: Returns:
Boolean value: true if at least one vertex has color,
false otherwise.

This method determines whether the current face vertex has
color-per-vertex set.'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: Returns:
The vertex position

Arguments:
	[in]	space = MSpace.Space

Return the position of the current face vertex.'''
        pass

class MItMeshPolygon:
    '''Polygon iterator.'''
    def __init__(self):
        pass


    def isHoled(self): 
        '''isHoled(self) -> bool
Returns: Returns:
Boolean value: true the face has one or more holes,
false otherwise.

This method checks if the face has any holes.'''
        pass

    def onBoundary(self): 
        '''onBoundary(self) -> bool
Returns: Returns:
Boolean value: true if on a boundary, false
otherwise.

This method determines whether the current face is on a
boundary'''
        pass

    def isPlanar(self): 
        '''isPlanar(self) -> bool
Returns: Returns:
Boolean value: true the face is planar, false
otherwise.

This method checks if the face is planar'''
        pass

    def getNormals(self, space, normalArray): 
        '''getNormals(self, space, normalArray)
Arguments:
	[out]	normalArray = MVectorArray
	[in]	space = MSpace.Space

Returns the normals for all vertices in the current face'''
        pass

    def isConvex(self): 
        '''isConvex(self) -> bool
Returns: Returns:
Boolean value: true if the face is convex, false
otherwise.

This method checks if the face is convex.'''
        pass

    def point(self, index, space): 
        '''point(self, index, space) -> MPoint
Returns: Returns:
The vertex position

Arguments:
	[in]	index = int
	[in]	space = MSpace.Space

Return the position of the vertex at  index  in the current
polygon.'''
        pass

    def getConnectedFaces(self, faces): 
        '''getConnectedFaces(self, faces)
Arguments:
	[out]	faces = MIntArray

This method gets the indices of the faces connected to the
current face.'''
        pass

    def setUV(self, vertexId, uvPoint, uvSet): 
        '''setUV(self, vertexId, uvPoint, uvSet)
Arguments:
	[in]	vertexId = int
	[in]	uvPoint = float2
	[in]	uvSet = MString

Modify the UV value for the given vertex in the current face. If
the face is not already mapped, this method will fail.'''
        pass

    def isConnectedToFace(self, index): 
        '''isConnectedToFace(self, index) -> bool
Returns: Returns:
true if connected, false otherwise.

Arguments:
	[in]	index = int

This method determines whether the given face is adjacent to the
current face'''
        pass

    def numTriangles(self, triCount): 
        '''numTriangles(self, triCount)
Arguments:
	[out]	triCount = int

This Method checks for the number of triangles in this face in
the current triangulation'''
        pass

    def setIndex(self, index, prevIndex): 
        '''setIndex(self, index, prevIndex)
Arguments:
	[in]	index = int
	[in]	prevIndex = int

This method sets the index of the current face to be accessed.
The current face will no longer be in sync with any previous
iteration.'''
        pass

    def getConnectedEdges(self, edges): 
        '''getConnectedEdges(self, edges)
Arguments:
	[out]	edges = MIntArray

This method gets the indices of the edges connected to the
vertices of the current face, but DOES not include the edges
contained in the current face'''
        pass

    def setUVs(self, uArray, vArray, uvSet): 
        '''setUVs(self, uArray, vArray, uvSet)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	uvSet = MString

Modify the UV value for all vertices in the current face. If the
face has not already been mapped, this method will fail.'''
        pass

    def hasColor(self, vertexIndex): 
        '''hasColor(self, vertexIndex) -> bool
Returns: Returns:
Boolean value: true if the given vertex has color,
false otherwise.

Arguments:
	[in]	vertexIndex = int

This method determines whether the current face has
color-per-vertex set for the given vertex.'''
        pass

    def isLamina(self): 
        '''isLamina(self) -> bool
Returns: Returns:
Boolean value: true if the face is a lamina,
false otherwise.

This method checks if the face is a lamina (the face is folded
over onto itself).'''
        pass

    def getUVIndex(self, vertex, uvSet, index, u, v): 
        '''getUVIndex(self, vertex, uvSet, index, u, v)
Arguments:
	[in]	vertex = int
	[out]	index = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString

Return the index of the texture coordinate for the given vertex.
This index refers to an element of the texture coordinate array for
the polygonal object returned by  MFnMesh::getUVs .'''
        pass

    def hasUVs(self, uvSet): 
        '''hasUVs(self, uvSet) -> bool
Returns: Returns:
Boolean value: true if the face has UV's mapped,
false otherwise

Arguments:
	[in]	uvSet = MString

Tests whether this face has UV's mapped or not (either all the
vertices for a face should have UV's, or none of them do, so the UV
count for a face is either 0, or equal to the number of
vertices).'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)
Reset the geom pointer in the  MItMeshPolygon . This is now being handled
automatically inside the iterator, and users should no longer need
to call this method directly to sync up the iterator to changes
made by  MFnMesh'''
        pass

    def normalIndex(self, localVertexIndex): 
        '''normalIndex(self, localVertexIndex) -> int
Returns: Returns:
The index of the normal for the specified vertex

Arguments:
	[in]	localVertexIndex = int

Returns the normal index for the specified vertex. This index
refers to an element in the normal array returned by  MFnMesh::getNormals .
These normals are per-polygon per-vertex normals. See the  MFnMesh  description for more
information on normals.'''
        pass

    def getColorIndex(self, vertexIndex, colorSetName, colorIndex): 
        '''getColorIndex(self, vertexIndex, colorSetName, colorIndex)
Arguments:
	[in]	vertexIndex = int
	[out]	colorIndex = int
	[in]	colorSetName = MString

This method returns the current colorIndex.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: Returns:
The index of the current polygon

Returns the index of the current polygon.'''
        pass

    def getVertices(self, vertices): 
        '''getVertices(self, vertices)
Arguments:
	[out]	vertices = MIntArray

This method gets the indices of the vertices of the current
face'''
        pass

    def getArea(self, space, area): 
        '''getArea(self, space, area)
Arguments:
	[out]	area = double
	[in]	space = MSpace.Space

This method gets the area of the face'''
        pass

    def zeroUVArea(self, uvSet): 
        '''zeroUVArea(self, uvSet) -> bool
Returns: Returns:


true if the face has zero UV area
false otherwise.

Arguments:
	[in]	uvSet = MString

This method checks if the UV area of the face is zero'''
        pass

    def next(self): 
        '''next(self)
Advance to the next polygon in the iteration.'''
        pass

    def isConnectedToEdge(self, index): 
        '''isConnectedToEdge(self, index) -> bool
Returns: Returns:
Boolean value: true if connected, false
otherwise.

Arguments:
	[in]	index = int

This method determines whether the given edge is connected to a
vertex in the current face'''
        pass

    def numConnectedEdges(self, edgeCount): 
        '''numConnectedEdges(self, edgeCount)
Arguments:
	[out]	edgeCount = int

This method checks for the number of connected edges on the
vertices of this face'''
        pass

    def getColor(self, index, color): 
        '''getColor(self, index, color)
Arguments:
	[out]	color = MColor
	[in]	index = int

This method gets the color of the specifed vertex in this
face'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
The current polygon in the interation

Get the current polygon in the iteration as a component.'''
        pass

    def getEdges(self, edges): 
        '''getEdges(self, edges)
Arguments:
	[out]	edges = MIntArray

This method gets the indices of the edges contained in the
current face.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Boolean value: true if all polygons have been traversed,
false otherwise.

Indicates if all of the polygons have been traversed yet.'''
        pass

    def getUVAtPoint(self, pt, space, uvSet, uvPoint): 
        '''getUVAtPoint(self, pt, space, uvSet, uvPoint)
Arguments:
	[in]	pt = MPoint
	[out]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString

Find the point closest to the given point in the current
polygon, and return the UV value at that point.'''
        pass

    def count(self): 
        '''count(self) -> int
Returns: Returns:
The number of polygons in the iteration

Return the number of polygons in the iteration.'''
        pass

    def tangentIndex(self, localVertexIndex): 
        '''tangentIndex(self, localVertexIndex) -> int
Returns: Returns:
The index of the tangent for the specified vertex

Arguments:
	[in]	localVertexIndex = int

Returns the tangent (or binormal) index for the specified
vertex. This index refers to an element in the normal array
returned by  MFnMesh::getTangents .
These tangent or binormals are per-polygon per-vertex. See the
 MFnMesh  description for more
information on tangents and binormals.'''
        pass

    def getUVArea(self, uvSet, area): 
        '''getUVArea(self, uvSet, area)
Arguments:
	[out]	area = double
	[in]	uvSet = MString

This method gets the UV area of the face'''
        pass

    def getUVs(self, uvSet, uArray, vArray): 
        '''getUVs(self, uvSet, uArray, vArray)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray
	[in]	uvSet = MString

Return the all the texture coordinates for the vertices of this
face (in local vertex order).'''
        pass

    def numColors(self, colorSetName, colorCount): 
        '''numColors(self, colorSetName, colorCount)
Arguments:
	[out]	colorCount = int
	[in]	colorSetName = MString

This method checks for the number of colors on vertices in this
face.'''
        pass

    def getUVSetNames(self, setNames): 
        '''getUVSetNames(self, setNames)
Arguments:
	[out]	setNames = MStringArray

This method is used to find the UV set names mapped to the
current face.'''
        pass

    def getTriangle(self, localTriIndex, space, points, vertexList): 
        '''getTriangle(self, localTriIndex, space, points, vertexList)
Arguments:
	[in]	localTriIndex = int
	[out]	points = MPointArray
	[out]	vertexList = MIntArray
	[in]	space = MSpace.Space

Get the vertices and vertex positions of the given triangle in
the current face's triangulation.'''
        pass

    def zeroArea(self): 
        '''zeroArea(self) -> bool
Returns: Returns:
Boolean value: true if the face has zero area,
false otherwise.

This method checks if its a zero area face'''
        pass

    def hasValidTriangulation(self): 
        '''hasValidTriangulation(self) -> bool
Returns: Returns:
Boolean value: true the face has a valid triangulation
false otherwise.

This method checks if the face has a valid triangulation. If it
doesn't, then the face was bad geometry: it may gave degenerate
points or cross over itself.'''
        pass

    def getUV(self, vertex, uvSet, uvPoint): 
        '''getUV(self, vertex, uvSet, uvPoint)
Arguments:
	[in]	vertex = int
	[out]	uvPoint = float2
	[in]	uvSet = MString

Return the texture coordinate for the given vertex.'''
        pass

    def getColorIndices(self, colorSetName, colorIndices): 
        '''getColorIndices(self, colorSetName, colorIndices)
Arguments:
	[out]	colorIndices = MIntArray
	[in]	colorSetName = MString

This method returns the colorIndices for each vertex on the
face.'''
        pass

    def setPoints(self, pointArray, space): 
        '''setPoints(self, pointArray, space)
Arguments:
	[in]	pointArray = MPointArray
	[in]	space = MSpace.Space

Sets new locations for vertices of the current polygon that the
iterator is pointing to.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)
Signal that this polygonal surface has changed and needs to
redraw itself.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject

Reset the iterator with the given surface and component. If
component is null then the iteration will be for all polygons in
the given surface.'''
        pass

    def getPointAtUV(self, uvPoint, space, uvSet, tolerance, pt): 
        '''getPointAtUV(self, uvPoint, space, uvSet, tolerance, pt)
Arguments:
	[out]	pt = MPoint
	[in]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString
	[in]	tolerance = float

Return the position of the point at the given UV value in the
current polygon.'''
        pass

    def isConnectedToVertex(self, index): 
        '''isConnectedToVertex(self, index) -> bool
Returns: Returns:
Boolean value: true if connected, false
otherwise.

Arguments:
	[in]	index = int

This method determines whether the given vertex shares an edge
with a vertex in the current face.'''
        pass

    def center(self, space): 
        '''center(self, space) -> MPoint
Returns: Returns:
The center of the current polygon

Arguments:
	[in]	space = MSpace.Space

Return the position of the center of the current polygon.'''
        pass

    def getPoints(self, space, pointArray): 
        '''getPoints(self, space, pointArray)
Arguments:
	[out]	pointArray = MPointArray
	[in]	space = MSpace.Space

Retrieves the positions of the vertices on the current
face/polygon that the iterator is pointing to. Vertex positions
will be inserted into the given array and will be indexed using
face-relative vertex IDs (ie. ordered from 0 to (vertexCount of the
face) - 1), which should not be confused with the vertexIDs of each
vertex in relation to the entire mesh object.'''
        pass

    def setPoint(self, point, index, space): 
        '''setPoint(self, point, index, space)
Arguments:
	[in]	point = MPoint
	[in]	index = int
	[in]	space = MSpace.Space

Set the vertex at the given index in the current polygon.'''
        pass

    def getNormal(self, index, space, normal): 
        '''getNormal(self, index, space, normal)
Arguments:
	[in]	index = int
	[out]	normal = MVector
	[in]	space = MSpace.Space

Returns the vertex-face normal for the vertex in the current
polygon.'''
        pass

    def vertexIndex(self, index): 
        '''vertexIndex(self, index) -> int
Returns: Returns:
The index in the polygon array of the given vertex

Arguments:
	[in]	index = int

Returns the object-relative index of the specified vertex of the
current polygon. The index returned may be used to refer to an
element in the vertex list returned by  MFnMesh::getPoints .'''
        pass

    def getConnectedVertices(self, vertices): 
        '''getConnectedVertices(self, vertices)
Arguments:
	[out]	vertices = MIntArray

This method gets the object-relative indices of the vertices
surrounding the vertices of the current face, but does not include
the vertices of the current face'''
        pass

    def isStarlike(self): 
        '''isStarlike(self) -> bool
Returns: Returns:
Boolean value: true if the face is starlike,
false otherwise.

This method checks if the face is starlike. That is, a line from
the centre to any vertex lies entirely within the face.'''
        pass

    def getTriangles(self, space, points, vertexList): 
        '''getTriangles(self, space, points, vertexList)
Arguments:
	[out]	points = MPointArray
	[out]	vertexList = MIntArray
	[in]	space = MSpace.Space

Get the vertices and vertex positions of all the triangles in
the current face's triangulation.'''
        pass

    def getColors(self, colorSetName, colors): 
        '''getColors(self, colorSetName, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSetName = MString

This method gets the color of the each vertex in the current
face.'''
        pass

    def polygonVertexCount(self): 
        '''polygonVertexCount(self) -> int
Returns: Returns:
The number of vertices for the current polygon

Return the number of vertices for the current polygon.'''
        pass

    def numConnectedFaces(self, faceCount): 
        '''numConnectedFaces(self, faceCount)
Arguments:
	[out]	faceCount = int

This method checks for the number of connected faces'''
        pass

class MItMeshVertex:
    '''Polygon vertex iterator.'''
    def __init__(self):
        pass


    def onBoundary(self): 
        '''onBoundary(self) -> bool
Returns: Returns:
Boolean value: true if contained, false
otherwise.

This method determines whether the current vertex is on a
Boundary'''
        pass

    def connectedToFace(self, index): 
        '''connectedToFace(self, index) -> bool

Arguments:
	[in]	index = int

This method determines whether the given face contains the
current vertex'''
        pass

    def connectedToEdge(self, index): 
        '''connectedToEdge(self, index) -> bool

Arguments:
	[in]	index = int

This method determines whether the given edge contains the
current vertex'''
        pass

    def getConnectedFaces(self, faces): 
        '''getConnectedFaces(self, faces)
Arguments:
	[out]	faces = MIntArray

This method gets the indices of the faces connected to the
current vertex.'''
        pass

    def getNormal(self, faceIndex, space, vector): 
        '''getNormal(self, faceIndex, space, vector)
Arguments:
	[out]	vector = MVector
	[in]	faceIndex = int
	[in]	space = MSpace.Space

Return the normal of the current vertex in the specified
face'''
        pass

    def setIndex(self, index, prevIndex): 
        '''setIndex(self, index, prevIndex)
Arguments:
	[in]	index = int
	[in]	prevIndex = int

This method sets the index of the current vertex to be accessed.
The current vertex will no longer be in sync with any previous
iteration.'''
        pass

    def getConnectedEdges(self, edges): 
        '''getConnectedEdges(self, edges)
Arguments:
	[out]	edges = MIntArray

This method gets the indices of the edges connected to the
current vertex.'''
        pass

    def setUVs(self, uArray, vArray, faceIds, uvSet): 
        '''setUVs(self, uArray, vArray, faceIds, uvSet)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	faceIds = MIntArray
	[in]	uvSet = MString

Set the UV value for the specified faces at the current vertex.
If the face is not already mapped, the value will not be set. If at
least ne face was previously mapped, the method should succeed. If
no faces were mapped, the method will fail.'''
        pass

    def getNormalIndices(self, normalIndices): 
        '''getNormalIndices(self, normalIndices)
Arguments:
	[out]	normalIndices = MIntArray

This method returns the normal indices of the face/vertex
associated with the current vertex.'''
        pass

    def getNormals(self, space, normalArray): 
        '''getNormals(self, space, normalArray)
Arguments:
	[out]	normalArray = MVectorArray
	[in]	space = MSpace.Space

Return the normals of the current vertex for all faces'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)
Reset the geom pointer in the  MItMeshVertex . If you're using
 MFnMesh  to update Normals or
Color per vertex while iterating, you must call geomChanged on the
iteratior immediately after the  MFnMesh  call to make sure
that your geometry is up to date. A crash may result if this method
is not called. A similar approach must be taken for updating
upstream vertex tweaks with an  MPlug . After the
update, call this method.'''
        pass

    def numUVs(self, uvSet, uvCount): 
        '''numUVs(self, uvSet, uvCount)
Arguments:
	[out]	uvCount = int
	[in]	uvSet = MString

This method returns the number of unique UVs mapped on this
vertex'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: Returns:
The index in the vertex list for the current vertex

Returns the index of the current vertex in the vertex list for
this polygonal object. Polygonal objects contain a list of
vertices. Faces and edges are specified as indicies from this list,
in this way vertices can be shared amoung faces and edges.'''
        pass

    def getUVs(self, uvSet, uArray, vArray, faceIds): 
        '''getUVs(self, uvSet, uArray, vArray, faceIds)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray
	[out]	faceIds = MIntArray
	[in]	uvSet = MString

Get the UV values for all mapped faces at the current vertex. If
at least one face was mapped the method will succeed.'''
        pass

    def next(self): 
        '''next(self)
Advance to the next vertex in the iteration.'''
        pass

    def getUVIndices(self, uvSet, uvIndices): 
        '''getUVIndices(self, uvSet, uvIndices)
Arguments:
	[out]	uvIndices = MIntArray
	[in]	uvSet = MString

This method returns the uv indices into the normal array see
 MFnMesh::getUVs() 
of the current vertex.'''
        pass

    def getOppositeVertex(self, edgeId, vertexId): 
        '''getOppositeVertex(self, edgeId, vertexId)
Arguments:
	[out]	vertexId = int
	[in]	edgeId = int

This gets the other vertex of the given edge'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
The current vertex in the interation

Get the current vertex in the iteration as a component.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Boolean value: true if all vertices have been traversed,
false otherwise.

Indicates if all of the vertices have been traversed yet.'''
        pass

    def count(self): 
        '''count(self) -> int
Returns: Returns:
The number of vertices in the iteration

Return the number of vertices in the iteration.'''
        pass

    def getColor(self, colorSetName, color): 
        '''getColor(self, colorSetName, color)
Arguments:
	[out]	color = MColor
	[in]	colorSetName = MString

This method gets the average color of the vertex'''
        pass

    def getColorIndices(self, colorSetName, colorIndices): 
        '''getColorIndices(self, colorSetName, colorIndices)
Arguments:
	[out]	colorIndices = MIntArray
	[in]	colorSetName = MString

This method returns the colorIndices into the color array see
 MFnMesh::getColors() 
of the current vertex.'''
        pass

    def numConnectedEdges(self, edgeCount): 
        '''numConnectedEdges(self, edgeCount)
Arguments:
	[out]	edgeCount = int

This Method checks for the number of connected Edges on this
vertex'''
        pass

    def translateBy(self, vector, space): 
        '''translateBy(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Translate the current vertex by the amount specified by the
given vector.'''
        pass

    def getColors(self, colorSetName, colors): 
        '''getColors(self, colorSetName, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSetName = MString

This method gets the colors of the current vertex for each face
it belongs to. If no colors are assigned to the vertex at all, the
return values will be (-1 -1 -1 1). If some but not all of the
vertex/face colors have been explicitly set, the ones that have not
been set will be (0, 0, 0, 1).'''
        pass

    def getUV(self, faceId, uvSet, uvPoint): 
        '''getUV(self, faceId, uvSet, uvPoint)
Arguments:
	[in]	faceId = int
	[out]	uvPoint = float2
	[in]	uvSet = MString

Get the UV value for the give facen at the current vertex'''
        pass

    def setPosition(self, point, space): 
        '''setPosition(self, point, space)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space

Set the position of the current vertex in the given space.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject

Reset the iterator with the given polygon and component. If
component is null then the iteration will be for all vertices in
the given polygon.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)
Signal that this polygonal surface has changed and needs to
redraw itself.'''
        pass

    def setUV(self, faceId, uvPoint, uvSet): 
        '''setUV(self, faceId, uvPoint, uvSet)
Arguments:
	[in]	faceId = int
	[in]	uvPoint = float2
	[in]	uvSet = MString

Set the UV value for the given face at the current vertex'''
        pass

    def hasColor(self, index): 
        '''hasColor(self, index) -> bool

Arguments:
	[in]	index = int

This method determines whether the given face has a color set
for the current vertex.'''
        pass

    def getConnectedVertices(self, vertices): 
        '''getConnectedVertices(self, vertices)
Arguments:
	[out]	vertices = MIntArray

This method gets the indices of the vertices surrounding the
current vertex'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: Returns:
The position of the vertex in the specified space

Arguments:
	[in]	space = MSpace.Space

Return the position of the current vertex in the specified
space. Object space ignores all transformations for the polygon,
world space includes all such transformations.'''
        pass

    def numConnectedFaces(self, faceCount): 
        '''numConnectedFaces(self, faceCount)
Arguments:
	[out]	faceCount = int

This Method checks for the number of Connected Faces'''
        pass

class MItSelectionList:
    '''Iterate over the items in the selection list.'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)
Reset the iterator. If a filter has been specified then the
current item will be the first selected item that matches the
filter.'''
        pass

    def itemType(self): 
        '''itemType(self) -> MItSelectionList.selItemType
Returns: Returns:


kDagSelectionItem - selection item is in the DAG
kAnimSelectionItem - selection item is a keyset
kDNselectionItem - selection item is a dependency node

Returns the current selection item type.'''
        pass

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


true the current selection item has components
false the current selection item does not have
components

Returns whether or not the current selection item has
components.'''
        pass

    def getDagPath(self, dagPath): 
        '''getDagPath(self, dagPath)
Arguments:
	[out]	dagPath = MDagPath

This method retrieves the dag path of the current selection
item.'''
        pass

    def next(self): 
        '''next(self)
Advance to the next item. If components are selected then
advance to next component.'''
        pass

    def getStrings(self, array): 
        '''getStrings(self, array)
Arguments:
	[out]	array = MStringArray

Get the string representation of the current item in the
selection list. It is possible that it will require more than one
string to represent the item (the item may contain groups of CVs
for example), so a string array is used to pass back the
results.'''
        pass

    def kDNselectionItem(self):
        '''This is an enum of selItemType.
Description: dependency node
Value: 2'''
        pass

    def kAnimSelectionItem(self):
        '''This is an enum of selItemType.
Description: keyset
Value: 1'''
        pass

    def kDagSelectionItem(self):
        '''This is an enum of selItemType.
Description: DAG node or component.
Value: 0'''
        pass

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

    class selItemType:
        '''Non-functional class.  Values for this enum:
        kDNselectionItem
        kAnimSelectionItem
        kDagSelectionItem
        kPlugSelectionItem
'''
        def __init__(self):
            pass

    def getPlug(self, plug): 
        '''getPlug(self, plug)
Arguments:
	[out]	plug = MPlug

This method retrieves the plug of the current selection
item.'''
        pass

    def setFilter(self, filter): 
        '''setFilter(self, filter)
Arguments:
	[in]	filter = MFn.Type

Apply a filter to the iteration. Selection items not matching
the filter type will be excluded from the iteration.'''
        pass

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


true if there is nothing else to iterate over
false if there are more items left to iterate over

Specifies whether or not there is anything more to iterator
over.'''
        pass

    def getDependNode(self, depNode): 
        '''getDependNode(self, depNode)
Arguments:
	[out]	depNode = MObject

This method retrieves the dependency node of the current
selection item'''
        pass

class MItSubdEdge:
    '''Subdiv edge iterator.'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)
Reset the iterator to the first edge.'''
        pass

    def index(self): 
        '''index(self) -> MUint64
Returns: Returns:
The index in the edge list for the current edge

Returns the index of the current edge in the edge list for this
subdiv object.'''
        pass

    def isSharp(self): 
        '''isSharp(self) -> bool
Returns: Returns:
boolean indicating whether the edge is sharp or not.

Returns true if the edge is sharp.'''
        pass

    def level(self): 
        '''level(self) -> int
Returns: Returns:
The level.

Returns the level of the subdiv object.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool
Returns: Returns:
bool Boolean to indicate whether the iterator is valid
or not.

Checks if the iterator is valid.'''
        pass

    def setLevel(self, level): 
        '''setLevel(self, level)
Arguments:
	[in]	level = int

Sets the level of the subdiv object'''
        pass

    def next(self): 
        '''next(self)
Advance to the next edge in the iteration.'''
        pass

    def isBoundary(self): 
        '''isBoundary(self) -> bool
Returns: Returns:
Boolean indicating whether the edge is boundary or not.

Checks if the edge is a boundary.'''
        pass

    def setSharpness(self, sharp): 
        '''setSharpness(self, sharp)
Arguments:
	[in]	sharp = bool

Marks the edge as sharp.'''
        pass

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


true All vertices have been traversed
false There are more vertices in the iteration

Indicates if all of the edges have been traversed yet.'''
        pass

class MItSubdFace:
    '''Subdiv face iterator.'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)
Reset the iterator to the first face.'''
        pass

    def index(self): 
        '''index(self) -> MUint64
Returns: Returns:
The index in the face list for the current face

Returns the index of the current face for this subdiv
object.'''
        pass

    def level(self): 
        '''level(self) -> int
Returns: Returns:
The level.

Returns the level of the subdiv object.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool
Returns: Returns:
bool Boolean to indicate whether the iterator is valid
or not.

Checks if the iterator is valid.'''
        pass

    def setLevel(self, level): 
        '''setLevel(self, level)
Arguments:
	[in]	level = int

Sets the level of the subdiv object'''
        pass

    def next(self): 
        '''next(self)
Advance to the next face in the iteration.'''
        pass

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


true All vertices have been traversed
false There are more vertices in the iteration

Indicates if all of the faces have been traversed yet.'''
        pass

class MItSubdVertex:
    '''Subdiv vertex iterator.'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)
Reset the iterator to the first vertex.'''
        pass

    def index(self): 
        '''index(self) -> MUint64

Returns the index of the current vertex in the vertex list for
this subdiv object.'''
        pass

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

Returns the level of the subdiv object.'''
        pass

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

Checks if the iterator is valid.'''
        pass

    def setLevel(self, level): 
        '''setLevel(self, level)
Arguments:
	[in]	level = int

Sets the level of the subdiv object'''
        pass

    def next(self): 
        '''next(self)
Advance to the next vertex in the iteration.'''
        pass

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

Indicates if all of the vertices have been traversed yet.'''
        pass

class MItSurfaceCV:
    '''NURBS surface CV iterator.'''
    def __init__(self):
        pass


    def reset(self, surface, component, useURows): 
        '''reset(self, surface, component, useURows)
Arguments:
	[in]	surface = MDagPath
	[in]	component = MObject
	[in]	useURows = bool

Reset the iterator to iterate over the CVs of the given surface
that are specified in the given component. If the component is NULL
then the iteration will be over all CVs on the surface.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: Returns:
The index for the current CV in the iteration

Get the index of the current CV as it appears in CV array for
this surface.'''
        pass

    def getIndex(self, indexU, indexV): 
        '''getIndex(self, indexU, indexV)
Arguments:
	[out]	indexU = int
	[out]	indexV = int

Get the index of the current CV as it appears in CV array for
this surface.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)
This method is used to signal the surface that it has been
changed and needs to redraw itself.'''
        pass

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

This method determines if the shape was created with
history.'''
        pass

    def isRowDone(self): 
        '''isRowDone(self) -> bool
Returns: Returns:
Boolean value: true if the current row in the iteration
is finished, false otherwise.

Returns  true  if the current row has no more CVs to
iterate over. The row can be in the U or V direction depending on
what value of  useURows  has been set in the constructor.'''
        pass

    def translateBy(self, space, vector): 
        '''translateBy(self, space, vector)
Arguments:
	[out]	vector = MVector
	[in]	space = MSpace.Space

Move the current CV in the iteration by the sepcified
vector.'''
        pass

    def next(self): 
        '''next(self)
Advance to the next CV in the iteration. If the iterator is
already at the last CV then this method has no effect. Use
 isDone  to determine if the iterator is at the last CV.'''
        pass

    def nextRow(self): 
        '''nextRow(self)
Advance to the next row in the iteration. The row can be in the
U or V direction depending on what value of  useURows  has
been set in the constructor.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Returns:
The current CV in the interation

Get the current CV in the iteration as a component.'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: Returns:
The position of the current CV in the iteration

Arguments:
	[in]	space = MSpace.Space

Returns the position of the current CV in the iteration in the
specified space.'''
        pass

    def setPosition(self, space, point): 
        '''setPosition(self, space, point)
Arguments:
	[out]	point = MPoint
	[in]	space = MSpace.Space

Set the position of the current CV in the iteration to the
specified point.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:
Boolean value: true if there are no more CVs to iterate
on, false otherwise.

Returns  true  if the iteration is finished, i.e. there are
no more CVs to iterate on.'''
        pass

class MLockMessage:
    '''Node and plug locking messages.'''
    def __init__(self):
        pass


    def kCreateNodeInstance(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on an instance event.
Value: 5'''
        pass

    def kLastDAG(self):
        '''This is an enum of LockDAGEvent.
Description: Used for internal bounds checking.
Value: 8'''
        pass

    def kUnGroup(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on ungroup action.
Value: 2'''
        pass

    def kInvalidDAG(self):
        '''This is an enum of LockDAGEvent.
Description: Invalid DAG event received.
Value: 0'''
        pass

    def kCreateChildInstance(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on node whose children will be instanced.
Value: 6'''
        pass

    def kChildReorder(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on a child add action.
Value: 4'''
        pass

    def kReparent(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on reparent action.
Value: 3'''
        pass

    def kGroup(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on group action.
Value: 1'''
        pass

    def kCreateParentInstance(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on node whose parent will be instanced.
Value: 7'''
        pass

    class LockDAGEvent:
        '''Non-functional class.  Values for this enum:
        kCreateNodeInstance
        kLastDAG
        kUnGroup
        kInvalidDAG
        kCreateChildInstance
        kChildReorder
        kReparent
        kGroup
        kCreateParentInstance
'''
        def __init__(self):
            pass

    def kInvalidPlug(self):
        '''This is an enum of LockPlugEvent.
Description: An invalid plug event received.
Value: 0'''
        pass

    def kPlugAttrValChange(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on plug value change.
Value: 3'''
        pass

    def kPlugRemoveAttr(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a remove attribute event.
Value: 4'''
        pass

    def kLastPlug(self):
        '''This is an enum of LockPlugEvent.
Description: Used for internal bounds checking.
Value: 8'''
        pass

    def kPlugConnect(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a connect to a locked attribute.
Value: 6'''
        pass

    def kPlugUnlockAttr(self):
        '''This is an enum of LockPlugEvent.
Description: User is trying to unlock the plug.
Value: 2'''
        pass

    def kPlugRenameAttr(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a rename attribute event.
Value: 5'''
        pass

    def kPlugDisconnect(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a disconnect from a locked source
attribute.
Value: 7'''
        pass

    def kPlugLockAttr(self):
        '''This is an enum of LockPlugEvent.
Description: User is trying to lock the plug.
Value: 1'''
        pass

    class LockPlugEvent:
        '''Non-functional class.  Values for this enum:
        kInvalidPlug
        kPlugAttrValChange
        kPlugRemoveAttr
        kLastPlug
        kPlugConnect
        kPlugUnlockAttr
        kPlugRenameAttr
        kPlugDisconnect
        kPlugLockAttr
'''
        def __init__(self):
            pass

    def setNodeLockDAGQueryCallback(self, dagPath, func, clientData): 
        '''setNodeLockDAGQueryCallback(self, dagPath, func, clientData) -> MCallbackId
Returns: Returns:
A unique id for the callback.

Arguments:
	[in]	dagPath = MDagPath
	[in]	func = MLockMessage.MLockDagEventFunction
	[in]	clientData = void

This methods registers a callback that is invoked in any
situation involving a locking condition on DAG level changes. When
called, the API user can make a decision on how to handle the given
locking situation. The programmer can either accept the default
action, or they can deny the default action. The decision is
returned through a decision variable which is passed to the
callback function.'''
        pass

    def setNodeLockQueryCallback(self, node, func, clientData): 
        '''setNodeLockQueryCallback(self, node, func, clientData) -> MCallbackId
Returns: Returns:
A unique id for the callback.

Arguments:
	[in]	node = MObject
	[in]	func = MLockMessage.MLockEventFunction
	[in]	clientData = void

This methods registers a callback that is invoked in any locking
condition on node properties, e.g. name, lock status, etc. When
called, the API user can make a decision on how to handle the given
locking situation. The programmer can either accept the default
action, or they can deny the default action. The decision is
returned through a decision variable which is passed to the
callback function.'''
        pass

    def setPlugLockQueryCallback(self, node, func, clientData): 
        '''setPlugLockQueryCallback(self, node, func, clientData) -> MCallbackId
Returns: Returns:
A unique id for the callback.

Arguments:
	[in]	node = MObject
	[in]	func = MLockMessage.MLockPlugEventFunction
	[in]	clientData = void

This method registers a callback that is invoked in any locking
condition on any plug of a given node, e.g. plug unlock, plug lock,
connections, etc. When the callback is invoked, the API programmer
can make a decision on how to handle the given locking situation.
The programmer can either accept the default action, or they can
deny the default action. The decision is returned through a
decision variable which is passed to the callback function.'''
        pass

    def kAddAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an add attribute event.
Value: 5'''
        pass

    def kRename(self):
        '''This is an enum of LockEvent.
Description: Lock query on a rename event.
Value: 1'''
        pass

    def kInvalid(self):
        '''This is an enum of LockEvent.
Description: Invalid node lock event received.
Value: 0'''
        pass

    def kDelete(self):
        '''This is an enum of LockEvent.
Description: Lock query on a delete event.
Value: 2'''
        pass

    def kUnlockAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an unlock attribute event.
Value: 8'''
        pass

    def kRemoveAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an remove attribute event.
Value: 6'''
        pass

    def kUnlockNode(self):
        '''This is an enum of LockEvent.
Description: Lock query on an unlock event.
Value: 4'''
        pass

    def kLockAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on a lock attribute event.
Value: 9'''
        pass

    def kLast(self):
        '''This is an enum of LockEvent.
Description: Used for internal bounds checking.
Value: 10'''
        pass

    def kRenameAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an rename attribute event.
Value: 7'''
        pass

    def kLockNode(self):
        '''This is an enum of LockEvent.
Description: Lock query on a lock event.
Value: 3'''
        pass

    class LockEvent:
        '''Non-functional class.  Values for this enum:
        kAddAttr
        kRename
        kInvalid
        kDelete
        kUnlockAttr
        kRemoveAttr
        kUnlockNode
        kLockAttr
        kLast
        kRenameAttr
        kLockNode
'''
        def __init__(self):
            pass

class MMatrix:
    '''A matrix math class for 4x4 matrices of doubles.'''
    def __init__(self):
        pass


    identity = ''
    '''The identity matrix.'''

    def setToIdentity(self): 
        '''setToIdentity(self) -> MMatrix

Set this instance to the 4x4 identity matrix. 
  Reprocessed example '''
        pass

    def inverse(self): 
        '''inverse(self) -> MMatrix

Compute and return the inverse of this instance.'''
        pass

    def setToProduct(self, left, right): 
        '''setToProduct(self, left, right) -> MMatrix

Arguments:
	[in]	left = MMatrix
	[in]	right = MMatrix

Set this instance to the inner product of the two argument
matrices.'''
        pass

    def homogenize(self): 
        '''homogenize(self) -> MMatrix

Compute and return a homogenized version of this instance.'''
        pass

    def __getitem__(self, row): 
        '''__getitem__(self, row) -> double*
Returns: Returns:


double array containing the values of the specified row

Arguments:
	[in]	row = int

Index operator. Returns an entire row of the matrix as an array
of doubles.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4

Fill a 4x4 matrix of floats with the elements from the
instance.'''
        pass

    def __rmult__(self, factor): 
        '''__rmult__(self, factor) -> MMatrix

Arguments:
	[in]	factor = double

'''
        pass

    def adjoint(self): 
        '''adjoint(self) -> MMatrix

Compute and return the adjoint of this instance.'''
        pass

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

Compute and return the determinant of this instance'''
        pass

    def transpose(self): 
        '''transpose(self) -> MMatrix

Compute and return the transpose of this instance.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: Returns:
true if the matrices are equivalent and false otherwise

Arguments:
	[in]	other = MMatrix
	[in]	tolerance = double

Determine if the given matrix is equivalent to this instance
within the specified tolerance.'''
        pass

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

Determines if the given matrix is singular.'''
        pass

    def __radd__(self, right): 
        '''__radd__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

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

Compute and return the determinant of the upper left 3x3
submatrix of this instance'''
        pass

    def __rsub__(self, right): 
        '''__rsub__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __mul__(self, factor, right): 
        '''__mul__(self, factor, right) -> MMatrix.OPENMAYA_EXPORT MMatrix

Arguments:
	[in]	factor = double
	[in]	right = MMatrix

'''
        pass

    def __add__(self, right): 
        '''__add__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __sub__(self, right): 
        '''__sub__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool

Arguments:
	[in]	other = MMatrix

'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool

Arguments:
	[in]	other = MMatrix

'''
        pass

class MMeshIntersector:
    '''Mesh intersector.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self, meshObject, matrix): 
        '''create(self, meshObject, matrix)
Arguments:
	[in]	meshObject = MObject
	[in]	matrix = MMatrix

This method creates the data required by the intersector. It is
a heavy operation that should be called only when necessary.'''
        pass

    def getClosestPoint(self, point, maxDistance, meshPoint): 
        '''getClosestPoint(self, point, maxDistance, meshPoint)
Arguments:
	[in]	point = MPoint
	[out]	meshPoint = MPointOnMesh
	[in]	maxDistance = double

This method finds the closest point. Information is returned in
the meshPoint object.'''
        pass

class MMeshSmoothOptions:
    '''Options for control of smooth mesh generation.'''
    def __init__(self):
        pass


    def divisions(self): 
        '''divisions(self) -> int
Returns: Returns:
The smoothing level

Retrieves the level of smoothing these options specify to
perform on the mesh.'''
        pass

    def setPropEdgeHardness(self, propEdgeHardness): 
        '''setPropEdgeHardness(self, propEdgeHardness)
Arguments:
	[in]	propEdgeHardness = bool

Sets whether or not these options specify that smooth mesh edges
which are a result of edges from the base cage will share the
hardness value'''
        pass

    def setDivisions(self, numDivisions): 
        '''setDivisions(self, numDivisions)
Arguments:
	[in]	numDivisions = int

Sets the number of divisions stored in this options object.'''
        pass

    def setKeepHardEdge(self, keepHardEdge): 
        '''setKeepHardEdge(self, keepHardEdge)
Arguments:
	[in]	keepHardEdge = bool

Sets whether or not these options specify that hard edges will
not be smoothed'''
        pass

    def keepBorderEdge(self): 
        '''keepBorderEdge(self) -> bool
Returns: Returns:
True if border edges will not be smoothed

Retrieves whether or not these options specify that border edges
will not be smoothed'''
        pass

    def keepHardEdge(self): 
        '''keepHardEdge(self) -> bool
Returns: Returns:
True if hard edges will not be smoothed

Retrieves whether or not these options specify that hard edges
will not be smoothed'''
        pass

    def boundaryRule(self): 
        '''boundaryRule(self) -> MMeshSmoothOptions.BoundaryRule

Returns the current value for the boundary rule as stored by
this option.'''
        pass

    def smoothness(self): 
        '''smoothness(self) -> float
Returns: Returns:
The smoothness parameter

Retrieves the smoothness parameter for this set of smooth
options which has range [0,1] where 1 smooths the faces as much as
possible'''
        pass

    def setKeepBorderEdge(self, keepBorderEdge): 
        '''setKeepBorderEdge(self, keepBorderEdge)
Arguments:
	[in]	keepBorderEdge = bool

Sets whether or not these options specify that border edges will
not be smoothed'''
        pass

    def setSmoothness(self, smoothness): 
        '''setSmoothness(self, smoothness)
Arguments:
	[in]	smoothness = float

Sets the the smoothness parameter for this set of smooth options
which has range [0,1] where 1 smooths the faces as much as
possible'''
        pass

    def setBoundaryRule(self, rule): 
        '''setBoundaryRule(self, rule)
Arguments:
	[in]	rule = MMeshSmoothOptions.BoundaryRule

Controls how boundary edges and vertices are creased. By
default, creases are automatically applied to all boundary edges
and all vertices that have only 2 incident edges prior to being
converted to a smooth mesh. Users can control this behavior by
modifying this enum.'''
        pass

    def kLegacy(self):
        '''This is an enum of BoundaryRule.
Description: Uses the legacy algorithm, which performed no creasing.
Value: 0'''
        pass

    def kLast(self):
        '''This is an enum of BoundaryRule.
Description: Last enum value.
Value: 3'''
        pass

    def kInvalid(self):
        '''This is an enum of BoundaryRule.
Description: Invalid value.
Value: -1'''
        pass

    def kCreaseAll(self):
        '''This is an enum of BoundaryRule.
Description: Crease boundary edges & vertices with valence of exactly
2.
Value: 1'''
        pass

    def kCreaseEdge(self):
        '''This is an enum of BoundaryRule.
Description: Crease boundary edges only.
Value: 2'''
        pass

    class BoundaryRule:
        '''Non-functional class.  Values for this enum:
        kLegacy
        kLast
        kInvalid
        kCreaseAll
        kCreaseEdge
'''
        def __init__(self):
            pass

    def setSmoothUVs(self, smoothUVs): 
        '''setSmoothUVs(self, smoothUVs)
Arguments:
	[in]	smoothUVs = bool

Sets whether or not these options specify to smooth UVs as well
as geometry.'''
        pass

    def propEdgeHardness(self): 
        '''propEdgeHardness(self) -> bool
Returns: Returns:
True if smooth edges share hardness with the base cage

Retrieves whether or not these options specify that the smooth
mesh edges which are a result of edges from the base cage will
share the same hardness value.'''
        pass

    def smoothUVs(self): 
        '''smoothUVs(self) -> bool
Returns: Returns:
True if UVs are set to be smoothed

Retrieves whether or not these options specify to smooth UVs as
well as geometry.'''
        pass

class MMessage:
    '''Message base class.'''
    def __init__(self):
        pass


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

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

'''
        pass

    def currentCallbackId(self): 
        '''currentCallbackId(self) -> MCallbackId
Returns: Returns:
Callback ID of currently executing callback

Return the callback ID of the currently executing callback. If
called outside of a callback, an invalid MCallbackId and failed
status will be returned.'''
        pass

    def nodeCallbacks(self, node, ids): 
        '''nodeCallbacks(self, node, ids)
Arguments:
	[in]	node = MObject
	[out]	ids = MCallbackIdArray

Returns a list of callback IDs associated registered to a given
node.'''
        pass

    def removeCallbacks(self, idList): 
        '''removeCallbacks(self, idList)
Arguments:
	[in]	idList = MCallbackIdArray

Remove all of the specified callbacks from maya.'''
        pass

    def removeCallback(self, id): 
        '''removeCallback(self, id)
Arguments:
	[in]	id = MCallbackId

Remove the specified callback from maya.'''
        pass

class MModelMessage:
    '''Scene messages.'''
    def __init__(self):
        pass


    def addNodeAddedToModelCallback(self, dagNode, func, clientData): 
        '''addNodeAddedToModelCallback(self, dagNode, func, clientData) -> MCallbackId

Arguments:
	[in]	dagNode = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void

Node added to model message.'''
        pass

    def addAfterDuplicateCallback(self, func, clientData): 
        '''addAfterDuplicateCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

After duplicate callback.'''
        pass

    def addBeforeDuplicateCallback(self, func, clientData): 
        '''addBeforeDuplicateCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

Before duplicate callback.'''
        pass

    def addNodeRemovedFromModelCallback(self, dagNode, func, clientData): 
        '''addNodeRemovedFromModelCallback(self, dagNode, func, clientData) -> MCallbackId

Arguments:
	[in]	dagNode = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void

Node removed from model message.'''
        pass

    def kActiveListModified(self):
        '''This is an enum of Message.
Description: active selection changes
Value: 0'''
        pass

    class Message:
        '''Non-functional class.  Values for this enum:
        kActiveListModified
'''
        def __init__(self):
            pass

    def addCallback(self, msg, func, clientData): 
        '''addCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MModelMessage.Message
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

Adds a new callback for the specified model message.'''
        pass

class MNamespace:
    '''Namespace.'''
    def __init__(self):
        pass


    def currentNamespace(self): 
        '''currentNamespace(self) -> MString
Returns: Returns:
The name of the current namespace as an absolute namepath.

Get the name of the current namespace. This name is returned as
an absolute namepath (i.e. fully qualfied from the root namespace
downwards, ":a:b:c").'''
        pass

    def rootNamespace(self): 
        '''rootNamespace(self) -> MString
Returns: Returns:
The name of the root namespace as an absolute namepath.

Get the name of the root namespace. This name is an absolute
namepath (i.e. prefixed by a ":"). An example use of this method
would be to set the current namespace to the root namespace, and
this could be done as follows:'''
        pass

    def setCurrentNamespace(self, name): 
        '''setCurrentNamespace(self, name)
Arguments:
	[in]	name = MString

Set the specified namespace to be the current namespace. The
`name' parameter you specify is relative to whatever namespace is
current, but any namespace can be specified by passing an absolute
name (e.g. :a:b:c). Note that making a namespace current changes
the scene, so any code that calls this method needs to handle
undo.'''
        pass

    def getNamespaceObjects(self, parentNamespace, recurse): 
        '''getNamespaceObjects(self, parentNamespace, recurse) -> MObjectArray
Returns: Returns:
The list of objects that belong to the namespace specified by
the 'parentNamespace' parameter. If the 'recurse' parameter was
also specified as true, the list will contain the objects belonging
to any child namespaces.

Arguments:
	[in]	parentNamespace = MString
	[in]	recurse = bool

Return an array of MObjects representing the object contained
within the specified namespace. To query the current namespace,
call this method thusly:'''
        pass

    def namespaceExists(self, name): 
        '''namespaceExists(self, name) -> bool
Returns: Returns:


true the namespace with the given name exists.
false the namespace with the given name does not
exist.

Arguments:
	[in]	name = MString

Check if a given namespace exists.'''
        pass

    def renameNamespace(self, oldName, newName, parent): 
        '''renameNamespace(self, oldName, newName, parent)
Arguments:
	[in]	oldName = MString
	[in]	newName = MString
	[in]	parent = MString

Rename the specified namespace to a new name with optional
parent name. Note that removing a namespace changes the scene, so
any code that calls this method needs to handle undo.'''
        pass

    def makeNamepathAbsolute(self, namepath): 
        '''makeNamepathAbsolute(self, namepath) -> MString
Returns: Returns:
The absolute namepath.

Arguments:
	[in]	namepath = MString

Make a namepath which is relative to the root into an absolute
namepath. For example, given the namepath "a:sphere" this method
returns ":a:sphere". It also culls out duplicate and trailing
separators, e.g. "a:b::c:" will return ":a:b:c".'''
        pass

    def getNamespaces(self, parentNamespace, recurse): 
        '''getNamespaces(self, parentNamespace, recurse) -> MStringArray
Returns: Returns:
The list of namespaces in the namespace specified via the
'namespacesToQuery' parameter.

Arguments:
	[in]	parentNamespace = MString
	[in]	recurse = bool

Return a list of all child namespaces of `parentNamespace', with
the option to list only direct children versus all descendents. To
list ALL namespaces in Maya, from the root downwards, specify the
root namespace, i.e.:'''
        pass

    def setRelativeNames(self, newState): 
        '''setRelativeNames(self, newState)
Arguments:
	[in]	newState = bool

Set relative name lookup mode. Note that turning on or off
relativeNames mode can change the scene, so any code that calls
this method needs to handle undo. See  MNamespace::relativeNames() 
for details on relative name lookup.'''
        pass

    def removeNamespace(self, name): 
        '''removeNamespace(self, name)
Arguments:
	[in]	name = MString

Remove the specified namespace. Note that removing a namespace
changes the scene, so any code that calls this method needs to
handle undo.'''
        pass

    def moveNamespace(self, src, dst, force): 
        '''moveNamespace(self, src, dst, force)
Arguments:
	[in]	src = MString
	[in]	dst = MString
	[in]	force = bool

Move the contents of the namespace `src' into the namespace
`dst'. Note that moving namespace contents changes the scene, so
any code that calls this method needs to handle undo.'''
        pass

    def addNamespace(self, name, parent): 
        '''addNamespace(self, name, parent)
Arguments:
	[in]	name = MString
	[in]	parent = MString

Create the namespace `name'. If the `parent' namespace is given
the new namespace will be a child of `parent', otherwise the new
namespace will be a child of the current namespace. The new
namespace is added, but not made current. To make the new namespace
be current use  MNamespace::setCurrentNamespace() .
Note that adding a namespace changes the scene, so any code that
calls this method needs to handle undo.'''
        pass

    def parentNamespace(self): 
        '''parentNamespace(self) -> MString
Returns: Returns:
The name of the current namespace's parent as an absolute
namepath.

Get the name of the current namespace's parent. This name is
returned as an absolute namepath (i.e. fully qualfied from the root
namespace downwards, ":a:b"). If the root namespace is current,
this method returns an error.'''
        pass

    def relativeNames(self): 
        '''relativeNames(self) -> bool
Returns: Returns:
true if relatve name lookup is on, false otherwise.

Query Maya's current "relative name lookup" state. Relative name
lookup causes lookups to be relative to the current namespace. By
default, relative name lookup in Maya is off, which causes name
lookups to be relative to the root namespace. For example, if you
have the object :a:b:sphere, and the current namespace is ":a:b",
in relative name lookup mode you can issue a command like'''
        pass

class MNodeMessage:
    '''Dependency node messages.The first parameter passed to each of the add callback methods is
the depenency node that will trigger the callback.'''
    def __init__(self):
        pass


    def addNodeDestroyedCallback(self, node, func, clientData): 
        '''addNodeDestroyedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

NodeDestroyed callback.'''
        pass

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

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

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

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

    class KeyableChangeMsg:
        '''Non-functional class.  Values for this enum:
        kKeyChangeInvalid
        kMakeUnkeyable
        kKeyChangeLast
        kMakeKeyable
'''
        def __init__(self):
            pass

    def addNodePreRemovalCallback(self, node, func, clientData): 
        '''addNodePreRemovalCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void

Registers a callback which will get called before a node is
deleted. This callback is called before connections on the node are
removed. Unlike the aboutToDelete callback, this callback will be
invoked whenever the node is deleted, even during a redo.'''
        pass

    def kAttributeArrayAdded(self):
        '''This is an enum of AttributeMessage.
Description: an array attribute has been added to this node
Value: 4096'''
        pass

    def kAttributeRenamed(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been renamed
Value: 256'''
        pass

    def kAttributeArrayRemoved(self):
        '''This is an enum of AttributeMessage.
Description: an array attribute has been removed from this node
Value: 8192'''
        pass

    def kConnectionBroken(self):
        '''This is an enum of AttributeMessage.
Description: a connection has been broken for an attribute of this node
Value: 2'''
        pass

    def kLast(self):
        '''This is an enum of AttributeMessage.
Description: last value of the enum
Value: 32768'''
        pass

    def kOtherPlugSet(self):
        '''This is an enum of AttributeMessage.
Description: the otherPlug data has been set
Value: 16384'''
        pass

    def kAttributeRemoved(self):
        '''This is an enum of AttributeMessage.
Description: an attribute has been removed from this node
Value: 128'''
        pass

    def kAttributeKeyable(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been marked keyable
Value: 512'''
        pass

    def kAttributeUnlocked(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been unlocked
Value: 32'''
        pass

    def kAttributeUnkeyable(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been marked unkeyable
Value: 1024'''
        pass

    def kAttributeLocked(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been locked
Value: 16'''
        pass

    def kIncomingDirection(self):
        '''This is an enum of AttributeMessage.
Description: the connection was coming into the node
Value: 2048'''
        pass

    def kAttributeAdded(self):
        '''This is an enum of AttributeMessage.
Description: an attribute has been added to this node
Value: 64'''
        pass

    def kAttributeEval(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been evaluated
Value: 4'''
        pass

    def kAttributeSet(self):
        '''This is an enum of AttributeMessage.
Description: an attribute value of this node has been set
Value: 8'''
        pass

    def kConnectionMade(self):
        '''This is an enum of AttributeMessage.
Description: a connection has been made to an attribute of this node
Value: 1'''
        pass

    class AttributeMessage:
        '''Non-functional class.  Values for this enum:
        kAttributeArrayAdded
        kAttributeRenamed
        kAttributeArrayRemoved
        kConnectionBroken
        kLast
        kOtherPlugSet
        kAttributeRemoved
        kAttributeKeyable
        kAttributeUnlocked
        kAttributeUnkeyable
        kAttributeLocked
        kIncomingDirection
        kAttributeAdded
        kAttributeEval
        kAttributeSet
        kConnectionMade
'''
        def __init__(self):
            pass

    def addKeyableChangeOverride(self, plug, func, clientData): 
        '''addKeyableChangeOverride(self, plug, func, clientData) -> MCallbackId

Arguments:
	[in]	plug = MPlug
	[in]	func = MNodeMessage.MKeyableFunction
	[in]	clientData = void

Attribute keyable state change override.'''
        pass

    def addAttributeAddedOrRemovedCallback(self, node, func, clientData): 
        '''addAttributeAddedOrRemovedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MNodeMessage.MAttrPlugFunction
	[in]	clientData = void

Registers callbacks for attribute add/removed messages. This is
a more specific version of addAttributeChanged as only attribute
added and attribute removed messages will trigger the callback.'''
        pass

    def addNodeDirtyPlugCallback(self, node, func, clientData): 
        '''addNodeDirtyPlugCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodePlugFunction
	[in]	clientData = void

Registers a callback for node dirty messages. This callback
provides the plug on the node that was dirtied. Only provides dirty
information on input plugs.'''
        pass

    def addAttributeChangedCallback(self, node, func, clientData): 
        '''addAttributeChangedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MNodeMessage.MAttr2PlugFunction
	[in]	clientData = void

This method registers a callback for attribute changed messages.
See the AttributeChanged enum for a list of all possible messages
that will trigger the callback.'''
        pass

class MNurbsIntersector:
    '''Nurbs intersector.'''
    def __init__(self):
        pass


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

'''
        pass

    def create(self, nurbsObject, matrix): 
        '''create(self, nurbsObject, matrix)
Arguments:
	[in]	nurbsObject = MObject
	[in]	matrix = MMatrix

This method creates the data required by the intersector. It is
a heavy operation that should be called only when necessary, such
as when the underlying NURBS surface or the matrix changes.'''
        pass

    def getIntersect(self, rayStartingPoint, alongThisDirection, tolerance, u, v, pntOfIntersection): 
        '''getIntersect(self, rayStartingPoint, alongThisDirection, tolerance, u, v, pntOfIntersection)
Arguments:
	[in]	rayStartingPoint = MPoint
	[in]	alongThisDirection = MVector
	[out]	u = double
	[out]	v = double
	[out]	pntOfIntersection = MPoint
	[in]	tolerance = double

This method finds the first point of intersection of the NURBS
surface with a ray (a vector at a point). The point is returned in
the pntOfIntersection object, and the U and V parameters of the
point are returned in the u and v variables respectively.'''
        pass

    def getClosestPoint(self, point, maxDistance, nurbsPoint): 
        '''getClosestPoint(self, point, maxDistance, nurbsPoint)
Arguments:
	[in]	point = MPoint
	[out]	nurbsPoint = MPointOnNurbs
	[in]	maxDistance = double

This method finds the closest point. Information is returned in
the nurbsPoint object.'''
        pass

    def getIntersects(self, rayStartingPoint, alongThisDirection, uArray, vArray, tolerance, points): 
        '''getIntersects(self, rayStartingPoint, alongThisDirection, uArray, vArray, tolerance, points)
Arguments:
	[in]	rayStartingPoint = MPoint
	[in]	alongThisDirection = MVector
	[in]	uArray = MDoubleArray
	[in]	vArray = MDoubleArray
	[out]	points = MPointArray
	[in]	tolerance = double

This method finds all the points of intersection of the NURBS
surface with a ray (a vector at a point). The points are returned
in the points object, and the U and V parameters of the points are
returned in the uArray and vArray objects respectively.'''
        pass

class MObject:
    '''Generic Class for Accessing Internal Maya Objects'''
    def __init__(self):
        pass


    kNullObj = ''
    '''Null Object for use as default
argument.'''

    def hasFn(self, fs): 
        '''hasFn(self, fs) -> bool
Returns: Returns:


true Is compatible
false Is not compatible

Arguments:
	[in]	fs = MFn.Type

Determines the whether or not the internal Object is compatible
with the given Function Type.'''
        pass

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

Returns a string that gives the object's type is a readable
form. This is useful for debugging when type of an object needs to
be printed.'''
        pass

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

Determines the exact type of the Maya internal Object.'''
        pass

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

Determines the whether or not an internal Object exists.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool

Arguments:
	[in]	other = MObject

'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool

Arguments:
	[in]	other = MObject

'''
        pass

class MObjectArray:
    '''Array of MObjects data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MObject
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MObject
	[in]	index = int

Sets the value of the indicated element to the indicated
 MObject  value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MObject
Returns: Returns:
A reference to the indicated element

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MObject

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MObjectHandle:
    '''Generic Class for validating MObjects.'''
    def __init__(self):
        pass


    def objectRef(self): 
        '''objectRef(self) -> const MObject

Returns the  MObject 
associated with this handle. This provides read-only access to the
 MObject  that  MObjectHandle  holds
onto. This method will always return the object that belongs to
 MObjectHandle 
regardless of its validity. API users should use caution when using
 MObject  data when it
is not valid, and should never use the data when  MObjectHandle 
indicates that the  MObject  is NOT alive.'''
        pass

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

Returns the live state of the associated  MObject . An object can still be 'alive'
but not 'valid' (eg. a deleted object that resides in the undo
queue).'''
        pass

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

Returns the validity of the associated  MObject .'''
        pass

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

Returns the  MObject 
associated with this handle. The returned  MObject  will be  MObject::kNullObj  if
the object is invalid.'''
        pass

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

Returns a hash code for the internal Maya object referenced by
the  MObject  within
this  MObjectHandle . If the
 MObject  is null or no
longer alive then 0 will be returned, otherwise the hash code is
guaranteed to be non-zero.'''
        pass

    def __eq__(self, handle): 
        '''__eq__(self, handle) -> bool
Returns: Returns:
true if the MObjectHandles are the same, false
otherwise.

Arguments:
	[in]	handle = MObjectHandle

Returns true if the  MObjectHandle  handles
the same  MObject  as
this  MObjectHandle .'''
        pass

    def __neq__(self, handle): 
        '''__neq__(self, handle) -> bool
Returns: Returns:
true MObjectHandles are not the same, false
otherwise.

Arguments:
	[in]	handle = MObjectHandle

Returns true if the  MObjectHandle  does not
handle the same  MObject  as this  MObjectHandle .'''
        pass

class MObjectSetMessage:
    '''Object Set Messages.The first parameter passed to each of the add callback methods is
the object set depenency node that will trigger the callback. The
second parameter specifies the callback function and the optional
third parameter specifies the callback argument.'''
    def __init__(self):
        pass


    def addSetMembersModifiedCallback(self, node, func, clientData): 
        '''addSetMembersModifiedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void

Registers callbacks for set modified messages.'''
        pass

class MPlane:
    '''A plane equation.'''
    def __init__(self):
        pass


    def distance(self, point): 
        '''distance(self, point) -> double
Returns: Returns:
The distance from the specified point to the plane.

Arguments:
	[in]	point = MVector

Returns the unsigned distance from the plane to the specified
point.'''
        pass

    def directedDistance(self, point): 
        '''directedDistance(self, point) -> double
Returns: Returns:
The distance from the specified point to the plane.

Arguments:
	[in]	point = MVector

Returns the signed distance from the plane to the specified
point.'''
        pass

    def setPlane(self, n, d): 
        '''setPlane(self, n, d)
Arguments:
	[in]	n = MVector
	[in]	d = double

Set the equation of the plane from a normal and offset.'''
        pass

    def normal(self): 
        '''normal(self) -> MVector

Returns the normal of the plane.'''
        pass

class MPlug:
    '''Create and Access dependency node plugs.'''
    def __init__(self):
        pass


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


true
false

This method determines if the plug is an array plug. Array plugs
refer to array attributes and contain element plugs.'''
        pass

    def asMAngle(self, ctx): 
        '''asMAngle(self, ctx) -> MAngle
Returns: Returns:
Value of plug as an MAngle

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def elementByLogicalIndex(self, index): 
        '''elementByLogicalIndex(self, index) -> MPlug
Returns: Returns:
A plug with the given index

Arguments:
	[in]	index = int

This method will find and return a plug with the given logical
index. The logical index is the sparse array index used in MEL
scripts. If a plug does not exist at the given Index, Maya will
create a plug at that index. This is not the case with  elementByPhysicalIndex() .
If needed, elementByLogicalIndex can be used to expand an array
plug on a node. It is important to note that Maya assumes that all
such plugs serve a purpose and it will not free non-networked plugs
that result from such an array expansion.'''
        pass

    def setMDataHandle(self, handle): 
        '''setMDataHandle(self, handle)
Arguments:
	[in]	handle = MDataHandle

Set the current value of the attribute this plug references with
the values in the handle. This method is most useful when the plug
is an array plug, and you've filled the handle with data. Sending
the value using this version of setValue will set the handle's data
into the datablock and send out the appropriate attributeChanged
messages to update the UI related to the attribute.'''
        pass

    def attribute(self): 
        '''attribute(self) -> MObject
Returns: Returns:
The attribute that this plug refers to.

This method returns the attribute that this plug refers to.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MPlug

Arguments:
	[in]	index = int

Returns a plug to a given attribute that is a child of this
plug. This method is only valid for compound plugs.'''
        pass

    def __getitem__(self, physicalIndex): 
        '''__getitem__(self, physicalIndex) -> MPlug
Returns: Returns:
A plug with the given index

Arguments:
	[in]	physicalIndex = int

This method will find and return a plug with the given physical
index. This is the same as the  elementByPhysicalIndex 
method.'''
        pass

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


true If this plug is connected to another plug
false If this plug is not connected to another plug

Determines if this plug is connected to one or more plugs.'''
        pass

    def connectedTo(self, array, asDst, asSrc): 
        '''connectedTo(self, array, asDst, asSrc) -> bool
Returns: Returns:


true If the plug has connections as either source or
destination. Note that the array is filled in only with the type of
connecting plugs requested by asSrc and asDst. Therefore, the
method could return true while the array has nothing in it if, for
example, the plug has connections as source but the user passes
asSrc = false to the method. The parameters asSrc and asDst have no
effect on the boolean return value. Setting one true and one false
and then checking the length of the array after calling this method
is a way to determine whether the connections are source or
destination.
false If this plug has no connections

Arguments:
	[in]	array = MPlugArray
	[in]	asDst = bool
	[in]	asSrc = bool

This method finds all of the plugs that this plug is connected
with. This method will always produce the networked version of the
connected plugs.'''
        pass

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


true
false

This method determines if the plug is a procedural plug. A
procedural plug is one which is created by Maya's internal
procedures or by the nodes themselves and which should not be saved
to or restored from files.'''
        pass

    def numConnectedChildren(self): 
        '''numConnectedChildren(self) -> int
Returns: Returns:
Total number of children

Return the number of children of this plug that are connected in
the dependency graph.'''
        pass

    def setMObject(self, val): 
        '''setMObject(self, val)
Arguments:
	[in]	val = MObject

Set the current value of the attribute this plug references.'''
        pass

    def setBool(self, val): 
        '''setBool(self, val)
Arguments:
	[in]	val = bool

Set the current value of the attribute this plug references.'''
        pass

    def asDouble(self, ctx): 
        '''asDouble(self, ctx) -> double
Returns: Returns:
Value of plug as a double

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def array(self): 
        '''array(self) -> MPlug
Returns: Returns:
The array of this plug.

Returns the array to which this element plug belongs. This
method is only valid for networked element plugs.'''
        pass

    def asString(self, ctx): 
        '''asString(self, ctx) -> MString
Returns: Returns:
Value of plug as an MString

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def asFloat(self, ctx): 
        '''asFloat(self, ctx) -> float
Returns: Returns:
Value of plug as a float

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def setMTime(self, val): 
        '''setMTime(self, val)
Arguments:
	[in]	val = MTime

Set the current value of the attribute this plug references.'''
        pass

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


true caching flag has been set
false caching flag has not been set

Returns true if this plug or its attribute has its caching flag
set.'''
        pass

    def setMDistance(self, val): 
        '''setMDistance(self, val)
Arguments:
	[in]	val = MDistance

Set the current value of the attribute this plug references.'''
        pass

    def asChar(self, ctx): 
        '''asChar(self, ctx) -> char
Returns: Returns:
Value of plug as a char

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def parent(self): 
        '''parent(self) -> MPlug
Returns: Returns:
The parent of this plug.

Returns the parent plug. The parent plug will always be a
compound plug. This method is only valid for networked child
plugs.'''
        pass

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


true plug is connected as a source
false plug is not connected as a source

Determines if this plug is connected as a source.'''
        pass

    def getExistingArrayAttributeIndices(self, indices): 
        '''getExistingArrayAttributeIndices(self, indices) -> int
Returns: Returns:
The number of set/connected elements

Arguments:
	[in]	indices = MIntArray

This method will return a list of the logical indices of the
elements in an array attribute that are either connected or have
had their value set. This method is useful when the logical indices
of connected/set elements are sparse.'''
        pass

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


true If the attribute is dynamic
false If this attribute is not added by user.

Determines whether the attribute is of dynamic type or not.'''
        pass

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


true plug was created within a referenced file
false plug was created within the current scene

This method determines whether this plug came from a referenced
file. A plug is considered to have come from a referenced file if
it is connected and that connection was made within a referenced
file.'''
        pass

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


true
false

This method determines if the plug is a compound plug. Compound
plugs refer to compound attributes and have child plugs.'''
        pass

    def numConnectedElements(self): 
        '''numConnectedElements(self) -> int
Returns: Returns:
Total number of elements

Return the total number of connected element plugs belonging to
this array plug.'''
        pass

    def setChar(self, val): 
        '''setChar(self, val)
Arguments:
	[in]	val = char

Set the current value of the attribute this plug references.'''
        pass

    def numElements(self): 
        '''numElements(self) -> int
Returns: Returns:
Total number of elements

Return the total number of elements in the datablock of this
array plug. The return count will include all existing
non-connected elements plus connected elements if they have been
evaluated. It will not include connected elements that have not yet
been placed into the datablock. The method  MPlug::evaluateNumElements 
can be used in the sitution where you want an accurate count that
includes all connected elements.'''
        pass

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


true If this plug's value is locked
false If this plug's value is not locked

Determines the locked state of this plug's value. A plug's
locked state determines whether or not the plug's value can be
changed.'''
        pass

    def setMAngle(self, val): 
        '''setMAngle(self, val)
Arguments:
	[in]	val = MAngle

Set the current value of the attribute this plug references.'''
        pass

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


true If this plug is keyable
false If this plug is not keyable

Determines if this plug is keyable. The default keyability of a
plug is determined by its attribute, and can be retrieved using
 MFnAttribute::isKeyable .
Keyable plugs will be keyed by AutoKey and the Set Keyframe UI.
Non-keyable plugs prevent the user from setting keys via the
obvious UI provided for keying. Being non-keyable is not a hard
block against adding keys to an attribute.'''
        pass

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


true
false

This method determines if the plug is an element plug. Element
plugs refer to array attributes and are members of array plugs.'''
        pass

    def asMTime(self, ctx): 
        '''asMTime(self, ctx) -> MTime
Returns: Returns:
Value of plug as an MTime

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def asMDistance(self, ctx): 
        '''asMDistance(self, ctx) -> MDistance
Returns: Returns:
Value of plug as an MDistance

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

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


true
false

This method determines if the plug is networked or
non-networked.'''
        pass

    def setString(self, val): 
        '''setString(self, val)
Arguments:
	[in]	val = MString

Set the current value of the attribute this plug references.'''
        pass

    def node(self): 
        '''node(self) -> MObject
Returns: Returns:
A pointer to this plug's dependency node.

Returns the dependency node that this plug belongs to.'''
        pass

    def setKeyable(self, keyable): 
        '''setKeyable(self, keyable)
Arguments:
	[in]	keyable = bool

This overrides the default keyability of a plug set with
 MFnAttribute::setKeyable .
Keyable plugs will be keyed by AutoKey and the Set Keyframe UI.
Non-keyable plugs prevent the user from setting keys via the
obvious UI provided for keying. Being non-keyable is not a hard
block against adding keys to an attribute.'''
        pass

    def __neq__(self, attr): 
        '''__neq__(self, attr) -> bool
Returns: Returns:


true If the plug's attribute is not equal
false If the plug's attribute is equal

Arguments:
	[in]	attr = MObject

The inequality operator for a plug and an attribute. This
actually compares the plug's attribute against the other
attribute.'''
        pass

    def selectAncestorLogicalIndex(self, index, attribute): 
        '''selectAncestorLogicalIndex(self, index, attribute)
Arguments:
	[in]	index = int
	[in]	attribute = MObject

This method is a convenience routine to allow quick iteration
and construction of plugs with array plugs in their ancestry. It
selects a plug into the current object by changing an ancestor
array's logical index.'''
        pass

    def getSetAttrCmds(self, valueSelector, useLongNames, cmds): 
        '''getSetAttrCmds(self, valueSelector, useLongNames, cmds)
Arguments:
	[out]	cmds = MStringArray
	[in]	valueSelector = MPlug.MValueSelector
	[in]	useLongNames = bool

Returns an array of strings containing  setAttr  commands
for this plug and all of its descendent plugs.'''
        pass

    def kChildrenNotFreeToChange(self):
        '''This is an enum of FreeToChangeState.
Description: Some of the children are not free to change.
Value: 2'''
        pass

    def kNotFreeToChange(self):
        '''This is an enum of FreeToChangeState.
Description: Some of the tested plugs are not free to change.
Value: 1'''
        pass

    def kFreeToChange(self):
        '''This is an enum of FreeToChangeState.
Description: All tested plugs are free to change.
Value: 0'''
        pass

    class FreeToChangeState:
        '''Non-functional class.  Values for this enum:
        kChildrenNotFreeToChange
        kNotFreeToChange
        kFreeToChange
'''
        def __init__(self):
            pass

    def setLocked(self, locked): 
        '''setLocked(self, locked)
Arguments:
	[in]	locked = bool

Sets the locked state for this plug's value. A plug's locked
state determines whether or not the plug's value can be
changed.'''
        pass

    def destructHandle(self, mHandle): 
        '''destructHandle(self, mHandle)
Arguments:
	[in]	mHandle = MDataHandle

'''
        pass

    def connectionByPhysicalIndex(self, index): 
        '''connectionByPhysicalIndex(self, index) -> MPlug
Returns: Returns:
A plug with the given index

Arguments:
	[in]	index = int

This method will find and return a connected plug with the given
physical index for its connection. The index can range from 0 to
 numConnectedElements() 
- 1. This method varies from elementByPhysicalIndex in that
elementByPhysicalIndex will return plugs pointing to all existing
data in the datablock regardless of whether the plug is connected
or not.'''
        pass

    def constructHandle(self, mBlock): 
        '''constructHandle(self, mBlock) -> MDataHandle

Arguments:
	[in]	mBlock = MDataBlock

This method returns a data handle constructed for this plug.'''
        pass

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


true channel box flag has been set
false channel box flag has not been set

Returns true if this plug or its attribute has its channel box
flag set. Attributes will appear in the channel box if their
channel box flag is set or if they are keyable.'''
        pass

    def elementByPhysicalIndex(self, index): 
        '''elementByPhysicalIndex(self, index) -> MPlug
Returns: Returns:
A plug with the given index

Arguments:
	[in]	index = int

This method will find and return a plug with the given physical
index. The index can range from 0 to  numElements() 
- 1. This function is particularly useful for iteration through the
element plugs of an array plug. It is equivalent to operator []
(int) This method is only valid for array plugs.'''
        pass

    def setCaching(self, isCaching): 
        '''setCaching(self, isCaching)
Arguments:
	[in]	isCaching = bool

Sets whether this plug is cached internally. Note: turning
caching on for a plug will force the plug to become networked.
Network plugs take longer to look up in the DG; therefore you
should only make a plug cached only if you are certain that the
network plug look-up will take less than the saved evaluation
cost.'''
        pass

    def logicalIndex(self): 
        '''logicalIndex(self) -> int
Returns: Returns:
The logical array index of the element this plug refers to

Returns the logical index of the element this plug refers to.
The logical index is a sparse index, equivalent to the array index
used in MEL.'''
        pass

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


true If connected, the attribute should be ingored
during rendering.
false If connected, the attribute should not be ingored
during rendering.

Determines whether a connection to the attribute should be
ignored during rendering.'''
        pass

    def __eq__(self, attr): 
        '''__eq__(self, attr) -> bool
Returns: Returns:


true If the plug's attribute is equal
false If the plug's attribute is not equal

Arguments:
	[in]	attr = MObject

Comparison operator for a plug and an attribute. This actually
compares the plug's attribute against the other attribute.'''
        pass

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


true
false

This method determines if the plug is a child plug. A child
plug's parent is always a compound plug.'''
        pass

    def setMPxData(self, val): 
        '''setMPxData(self, val)
Arguments:
	[in]	val = MPxData

Set the current value of the attribute this plug references.'''
        pass

    def asMObject(self, ctx): 
        '''asMObject(self, ctx) -> MObject
Returns: Returns:
Value of plug as an MObject

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def info(self): 
        '''info(self) -> MString
Returns: Returns:
Returns a string containing dependency node and attribute
information for this plug.

This method returns a string containing the name of the node
this plug belongs to and the attributes that the plug refers to.
The string is of the form dependNode:atr1.atr2[].attr3 ...'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: Returns:
The name of this node

Returns the name of this plug in the form
"<i>nodeName</i>.<i>attributeName</i>".'''
        pass

    def asBool(self, ctx): 
        '''asBool(self, ctx) -> bool
Returns: Returns:
Value of plug as a bool

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def asShort(self, ctx): 
        '''asShort(self, ctx) -> short
Returns: Returns:
Value of plug as a short

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def setShort(self, val): 
        '''setShort(self, val)
Arguments:
	[in]	val = short

Set the current value of the attribute this plug references.'''
        pass

    def setDouble(self, val): 
        '''setDouble(self, val)
Arguments:
	[in]	val = double

Set the current value of the attribute this plug references.'''
        pass

    def isFreeToChange(self, checkParents, checkChildren): 
        '''isFreeToChange(self, checkParents, checkChildren) -> MPlug.FreeToChangeState
Returns: Returns:


kFreeToChange All tested plugs are free to change.
kNotFreeToChange Some of the tested plugs are not free
to change.
kChildrenNotFreeToChange Some of the children are not
free to change.

Arguments:
	[in]	checkParents = bool
	[in]	checkChildren = bool

Returns true if the plug's value is allowed to be set directly.
A plug isFreeToChange if it is not locked, and it is not a
destination or if it is a destination, then it must be a special
case (such as connected to an anim curve).'''
        pass

    def setAttribute(self, attribute): 
        '''setAttribute(self, attribute)
Arguments:
	[in]	attribute = MObject

This method is a convenience routine to allow quick movement
between attributes on a single node. If the current plug is a
networked plug, it becomes a new non-networked plug referring to
the requested attribute. If the current plug is a non-networked
plug, it is changed to refer to the requested attribute.'''
        pass

    def setInt(self, val): 
        '''setInt(self, val)
Arguments:
	[in]	val = int

Set the current value of the attribute this plug references.'''
        pass

    def numChildren(self): 
        '''numChildren(self) -> int
Returns: Returns:
Total number of children

Return the total number of children of this compound plug.'''
        pass

    def kNonDefault(self):
        '''This is an enum of MValueSelector.
Description: Non default values.
Value: 1'''
        pass

    def kAll(self):
        '''This is an enum of MValueSelector.
Description: All values.
Value: 0'''
        pass

    def kChanged(self):
        '''This is an enum of MValueSelector.
Description: Changed values.
Value: 2'''
        pass

    def kLastAttrSelector(self):
        '''This is an enum of MValueSelector.
Description: Last value, for counting.
Value: 3'''
        pass

    class MValueSelector:
        '''Non-functional class.  Values for this enum:
        kNonDefault
        kAll
        kChanged
        kLastAttrSelector
'''
        def __init__(self):
            pass

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


true plug is connected as a destination
false plug is not connected as a destination

Determines if this plug is connected as a destination.'''
        pass

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


true this plug is not valid
false this plug is valid

This method determines whether this plug is valid. A plug is
valid if it refers to an attribute.'''
        pass

    def evaluateNumElements(self): 
        '''evaluateNumElements(self) -> int
Returns: Returns:
Total number of elements

Return the total number of elements in the datablock of this
array plug. The return count will include both connected and
non-connected elements, and will perform an evaluate in order to
make sure that the datablock is as up-to-date as possible since
some nodes do not place array elements into the datablock until the
attribute is evaluated.'''
        pass

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

Set the current value of the attribute this plug references.'''
        pass

    def setChannelBox(self, inChannelBox): 
        '''setChannelBox(self, inChannelBox)
Arguments:
	[in]	inChannelBox = bool

Sets whether this plug is displayed in the channel box. This
overrides the default display of a plug set with  MFnAttribute::setChannelBox .
Keyable attributes are always shown in the channel box so this flag
is ignored on keyable plugs.'''
        pass

    def partialName(self, includeNodeName, includeNonMandatoryIndices, includeInstancedIndices, useAlias, useFullAttributePath, useLongNames): 
        '''partialName(self, includeNodeName, includeNonMandatoryIndices, includeInstancedIndices, useAlias, useFullAttributePath, useLongNames) -> MString

Arguments:
	[in]	includeNodeName = bool
	[in]	includeNonMandatoryIndices = bool
	[in]	includeInstancedIndices = bool
	[in]	useAlias = bool
	[in]	useFullAttributePath = bool
	[in]	useLongNames = bool

By default, this method returns the shortest possible name for
the plug, but its parameters can be used to add parts back in.'''
        pass

    def asInt(self, ctx): 
        '''asInt(self, ctx) -> int
Returns: Returns:
Value of plug as an int

Arguments:
	[in]	ctx = MDGContext

Retrieve the current value of the attribute this plug
references.'''
        pass

    def setNumElements(self, elements): 
        '''setNumElements(self, elements)
Arguments:
	[in]	elements = int

The method is used to pre-allocate the number of elements that
an array plug will contain. The plug passed to this method must be
an array plug and there must be no elements already allocated.'''
        pass

class MPlugArray:
    '''Array of MPlugs data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MPlug
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MPlug
	[in]	index = int

Sets the value of the indicated element to the indicated
 MPlug  value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MPlug
Returns: Returns:
The value of the indicated element

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MPlug

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MPoint:
    '''Implementation of a point.'''
    def __init__(self):
        pass


    def rationalize(self): 
        '''rationalize(self) -> MPoint

'''
        pass

    

    def homogenize(self): 
        '''homogenize(self) -> MPoint

If this point instance is of the form P(x, y, z, W) (ie. is in
rational or (for W==1) cartesian form), for some scale factor W !=
0, then it is reset to be P(W*x, W*y, W*z, W). 
  Reprocessed example '''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double
Returns: Returns:
The value of the indicated component of the instance.

Arguments:
	[in]	i = int

The index operator.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4

Copy the values of x, y, z, and w from the instance to the four
elements of the given array of floats.'''
        pass

    def distanceTo(self, other): 
        '''distanceTo(self, other) -> double
Returns: Returns:
The distance between the two points.

Arguments:
	[in]	other = MPoint

Return the distance between this instance and the point passed
as an argument.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MPoint
Returns: Returns:
A point representing the product

Arguments:
	[in]	right = MMatrix

The in-place multiplication operator for computing the product
of this point instance with the given matrix.'''
        pass

    def cartesianize(self): 
        '''cartesianize(self) -> MPoint

'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: Returns:
True if the points are equal within the given tolerance and
false otherwise.

Arguments:
	[in]	other = MPoint
	[in]	tol = double

Returns true if this instance of the point passed as an argument
represent the same position within the specified tolerance.'''
        pass

    def __radd__(self, vector): 
        '''__radd__(self, vector) -> MPoint
Returns: Returns:
A reference to the resulting point.

Arguments:
	[in]	vector = MVector

The in-place addition operator for adding an  MVector  to an
 MPoint . The current instance is
translated from its original position by the vector.'''
        pass

    def __div__(self, scale): 
        '''__div__(self, scale) -> MPoint
Returns: Returns:
The resulting point.

Arguments:
	[in]	scale = double

The division operator that allows the vector to by scaled by the
given double parameter. The x, y, and z components are each divided
by the parameter. The w component remains unchanged.'''
        pass

    def __rsub__(self, vector): 
        '''__rsub__(self, vector) -> MPoint
Returns: Returns:
A reference to the resulting point.

Arguments:
	[in]	vector = MVector

The in-place subtraction operator for subtracting an  MVector  from an
 MPoint . The current instance is
translated from its original position by the inverse of the
vector.'''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> MPoint
Returns: Returns:
A point representing the product

Arguments:
	[in]	right = MMatrix

The multiplication operator for computing the product of this
point instance with the given matrix.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MPoint
Returns: Returns:
The resulting point.

Arguments:
	[in]	other = MVector

The addition operator for adding an  MVector  to an
 MPoint . A new point is returned
whose position is that of the original point translated by the
vector.'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MPoint
Returns: Returns:
The resulting point.

Arguments:
	[in]	other = MVector

The addition operator for subtracting an  MVector  from an
 MPoint . A new point is returned
whose position is that of the original point translated by the
inverse of the vector.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
True if all of the x, y, z components of the two points are
identical.

Arguments:
	[in]	other = MPoint

The equality operator.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:
True if any of the x, y, z components of the two points are not
identical.

Arguments:
	[in]	other = MPoint

The inequality operator.'''
        pass

class MPointArray:
    '''Array of MPoint data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MPoint
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, val, index): 
        '''set(self, val, index)
Arguments:
	[in]	val = float4
	[in]	index = int

Sets the value of the indicated element to the indicated value.
The x component of the element is set to val[0], the y component to
val[1], the z component to val[2], and the w component to
val[3].'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MPoint
Returns: Returns:
The value of the indicated element.

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float

Copy the elements of the array into the C++ array of float
arrays. No checking is done to ensure that the destination C++
array of float arrays is large enough to hold all the elements of
the instance.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MPointArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, x, y, z, w): 
        '''append(self, x, y, z, w)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double

Adds a new element to the end of the array. The appended element
has the indicated values for its x,y,z and w components. The x
component of the element is set to x, the y component to y, the z
component to z, and the w component to w.'''
        pass

class MPolyMessage:
    '''Polygon component id change messages.To remove a callback use MMessage::removeCallback.
All callbacks that are registered by a plug-in must be removed by
that plug-in when it is unloaded. Failure to do so will result in a
fatal error.'''
    def __init__(self):
        pass


    def addPolyComponentIdChangedCallback(self, node, wantIdModifications, count, func, clientData): 
        '''addPolyComponentIdChangedCallback(self, node, wantIdModifications, count, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	wantIdModifications = bool
	[in]	count = int
	[in]	func = MMessage.MComponentFunction
	[in]	clientData = void

This method registers a callback that should be called whenever
a poly component id is modified.'''
        pass

    def enum(self): 
        '''enum(self) -> anonymous

Values passed in addPolyComponentIdChangeCallback's
"wantIdModifications" array to indicate which component id changes
should trigger the callback.'''
        pass

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

This method returns a constant which is to be used to determine
if a component id has been deleted. Compare component ids returned
by the callback with the value return by this method. If they are
the same then, the component id has been deleted.'''
        pass

    def addPolyTopologyChangedCallback(self, node, func, clientData): 
        '''addPolyTopologyChangedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void

This method registers a callback that will be called when a node
impacting the topology of a meshShape is modified. Because the
callback is invoked before the mesh has evaluated, the new topology
data cannot be queried at the time the callback is received. If you
want to receive a callback at a time when the new mesh data can be
queried, use the following technique:'''
        pass

class MQuaternion:
    '''Quaternion math.'''
    def __init__(self):
        pass


    identity = ''
    '''The multiplicative identity.'''

    def scaleIt(self, scale): 
        '''scaleIt(self, scale) -> MQuaternion
Returns: Returns:
A reference to the quaternion that has been scaled

Arguments:
	[in]	scale = double

Performs an in place scaling of the quaternion. The result is a
quaternion whose x, y, z, and w values have been scaled by the
specified amount.'''
        pass

    def negateIt(self): 
        '''negateIt(self) -> MQuaternion

Performs an in place negation of the quaternion. The result is a
quaternion whose x, y, z, and w values have been negated.'''
        pass

    def conjugateIt(self): 
        '''conjugateIt(self) -> MQuaternion

Performs an in place conjugation of this quaternion. The result
is a quaternion whose x, y, and z values have been negated.'''
        pass

    def conjugate(self): 
        '''conjugate(self) -> MQuaternion

Returns the conjugate of this quaternion. The result is a
quaternion whose x, y, and z values have been negated.'''
        pass

    def setAxisAngle(self, axis, theta): 
        '''setAxisAngle(self, axis, theta) -> MQuaternion
Returns: Returns:
A reference to the quaternion that has had its axis and angle
set

Arguments:
	[in]	axis = MVector
	[in]	theta = double

Sets this quaternion to be the rotation as expressed by a pivot
axis and a rotation theta (in radians) about that axis. If the axis
is too small the quaternion returned will be the identity
quaternion.'''
        pass

    def asEulerRotation(self): 
        '''asEulerRotation(self) -> MEulerRotation

'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:


true the quaternions are not identical
false the quaternions are identical

Arguments:
	[in]	other = MQuaternion

The quaternion inequality operator. This returns false if all
four of the x, y, z, and w components are identical.'''
        pass

    def slerp(self, p, q, t): 
        '''slerp(self, p, q, t) -> MQuaternion.OPENMAYA_EXPORT MQuaternion
Returns: Returns:
Quaternion that has been interpolated from p to q

Arguments:
	[in]	p = MQuaternion
	[in]	q = MQuaternion
	[in]	t = double

Spherical linear interpolation (abbreviated as slerp) of unit
quaternions. As t goes from 0 to 1, the quaternion returned goes
from p to q. The interpolation always takes shortest path (in
quaternion space) from p to q.'''
        pass

    def inverse(self): 
        '''inverse(self) -> MQuaternion

Returns the inverse of this quaternion.'''
        pass

    def log(self): 
        '''log(self) -> MQuaternion

Returns the natural log of a quaternion. The precondition for
using this method is that the quaternion must be normalized.'''
        pass

    def normalizeIt(self): 
        '''normalizeIt(self) -> MQuaternion

Performs an in place normalization of this quaternion. The
result is a quaternion of unit length.'''
        pass

    def normal(self): 
        '''normal(self) -> MQuaternion

Returns the normal of this quaternion. The result is a
quaternion of unit length.'''
        pass

    def asMatrix(self): 
        '''asMatrix(self) -> MMatrix

Converts a quaternion to a 4X4 homogeneous rotation matrix. The
construction of the matrix assumes that the vectors are going to be
multiplied on the left side of the matrix. If the quaternion's
length has degenerated, this method will still produce a well
behaved matrix.'''
        pass

    def getAxisAngle(self, axis, theta): 
        '''getAxisAngle(self, axis, theta) -> bool
Returns: Returns:


true angle != 0
false angle == 0 (uses arbitrary axis, if given axis not
valid)

Arguments:
	[out]	axis = MVector
	[out]	theta = double

Converts this quaternion into a user understandable
representation. That is, the quaternion is represented as a pivot
vector 'axis' and a rotation 'theta' (in radians) about that pivot
vector.'''
        pass

    def setToZAxis(self, theta): 
        '''setToZAxis(self, theta) -> MQuaternion
Returns: Returns:
A reference to the quaternion that has been set to rotate about
the Z axis by the given amount

Arguments:
	[in]	theta = double

Sets this quaternion to be the rotation about the Z axis of
theta (in radians). If the length of the axis is too small the
quaternion returned will be the identity quaternion.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double
Returns: Returns:
The component of the quaternion corresponding to the index

Arguments:
	[in]	i = int

The index operator. If its argument is 0 it will return the x
component of the quaternion. If its argument is 1 it will return
the y component of the quaternion. If its argument is 2 it will
return the z component of the quaternion. If its argument is 3 it
will return the w component of the quaternion.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = double4

Extracts the x, y, z, and w components of the quaternion and
places them in elements 0, 1, 2, and 3 of the double array
passed.'''
        pass

    def setToYAxis(self, theta): 
        '''setToYAxis(self, theta) -> MQuaternion
Returns: Returns:
A reference to the quaternion that has been set to rotate about
the Y axis by the given amount

Arguments:
	[in]	theta = double

Sets this quaternion to be the rotation about the Y axis of
theta (in radians). If the length of the axis is too small the
quaternion returned will be the identity quaternion.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: Returns:


true the quaternions are equivalent
false the quaternions are not equivalent

Arguments:
	[in]	other = MQuaternion
	[in]	tolerance = double

This method returns true if this quaternion is equal, within
some given tolerance, to the other quaternion.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MQuaternion
Returns: Returns:
The sum of the two quaternions

Arguments:
	[in]	other = MQuaternion

The quaternion addition operator.'''
        pass

    def invertIt(self): 
        '''invertIt(self) -> MQuaternion

Performs an in place inversion of this quaternion.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:


true the quaternions are identical
false the quaternions are not identical

Arguments:
	[in]	other = MQuaternion

The quaternion equality operator. This returns true if all four
of the x, y, z, and w components are identical.'''
        pass

    def setToXAxis(self, theta): 
        '''setToXAxis(self, theta) -> MQuaternion
Returns: Returns:
A reference to the quaternion that has been set to rotate about
the X axis by the given amount

Arguments:
	[in]	theta = double

Sets this quaternion to be the rotation about the X axis of
theta (in radians). If the length of the axis is too small the
quaternion returned will be the identity quaternion.'''
        pass

    def __rmult__(self, other): 
        '''__rmult__(self, other) -> MQuaternion
Returns: Returns:
A reference to this quaternion which has been multiplied with
the other quaternion

Arguments:
	[in]	other = MQuaternion

The in place quaternion multiplication operator.'''
        pass

    def __mul__(self, other): 
        '''__mul__(self, other) -> MQuaternion
Returns: Returns:
The product of the two quaternions

Arguments:
	[in]	other = MQuaternion

This quaternion multiplication operator.'''
        pass

    def exp(self): 
        '''exp(self) -> MQuaternion

Exponentiates a quaternion that has a scalar part of zero. The
precondition for using this method is that w is zero.'''
        pass

    def __sub__(self): 
        '''__sub__(self) -> MQuaternion

The unary minus operator. Negates the value of each of the x, y,
z, and w components of the quaternion.'''
        pass

class MRampAttribute:
    '''Ramp data attribute function wrapper class.'''
    def __init__(self):
        pass


    def addEntries(self, positions, values, interps): 
        '''addEntries(self, positions, values, interps)
Arguments:
	[in]	positions = MFloatArray
	[in]	values = MFloatArray
	[in]	interps = MIntArray

Adds entries into a ramp attribute. If the ramp is a color ramp,
then this function will return a failure.'''
        pass

    def isColorRamp(self): 
        '''isColorRamp(self) -> bool
Returns: Returns:
true if the ramp is a color ramp, false otherwise

Checks to see whether this ramp is a color ramp.'''
        pass

    def getEntries(self, indices, positions, colors, interps): 
        '''getEntries(self, indices, positions, colors, interps)
Arguments:
	[out]	indices = MIntArray
	[out]	positions = MFloatArray
	[out]	colors = MColorArray
	[out]	interps = MIntArray

Gets all the entries in a ramp attribute. If the ramp is a curve
ramp, then this function will return a failure.'''
        pass

    def getColorAtPosition(self, position, color, context): 
        '''getColorAtPosition(self, position, color, context)
Arguments:
	[in]	position = float
	[out]	color = MColor
	[out]	context = MDGContext

Gets the color at a position'''
        pass

    def isCurveRamp(self): 
        '''isCurveRamp(self) -> bool
Returns: Returns:
true if the ramp is a curve ramp, false otherwise

Checks to see whether this ramp is a curve ramp.'''
        pass

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

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

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

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

    class MInterpolation:
        '''Non-functional class.  Values for this enum:
        kNone
        kLinear
        kSmooth
        kSpline
'''
        def __init__(self):
            pass

    def setPositionAtIndex(self, position, index): 
        '''setPositionAtIndex(self, position, index)
Arguments:
	[in]	position = float
	[in]	index = int

Sets the position of a given entry'''
        pass

    def deleteEntries(self, indices): 
        '''deleteEntries(self, indices)
Arguments:
	[in]	indices = MIntArray

Deletes entries in the ramp attribute.'''
        pass

    def getNumEntries(self): 
        '''getNumEntries(self) -> int
Returns: Returns:
The number of entries in the ramp attribute

Gets the number of entries in the ramp attribute.'''
        pass

    def createCurveRamp(self, attrLongName, attrShortName): 
        '''createCurveRamp(self, attrLongName, attrShortName) -> MObject
Returns: Returns:
Curve ramp attribute, returned as MObject.

Arguments:
	[in]	attrLongName = MString
	[in]	attrShortName = MString

This function creates the curve ramp attribute.'''
        pass

    def setInterpolationAtIndex(self, interp, index): 
        '''setInterpolationAtIndex(self, interp, index)
Arguments:
	[in]	interp = MRampAttribute.MInterpolation
	[in]	index = int

Sets the interpolation of a given entry'''
        pass

    def createColorRamp(self, attrLongName, attrShortName): 
        '''createColorRamp(self, attrLongName, attrShortName) -> MObject
Returns: Returns:
Color ramp attribute, returned as MObject.

Arguments:
	[in]	attrLongName = MString
	[in]	attrShortName = MString

This function creates the color ramp attribute.'''
        pass

    def setValueAtIndex(self, value, index): 
        '''setValueAtIndex(self, value, index)
Arguments:
	[in]	value = float
	[in]	index = int

Sets the value of a given entry'''
        pass

    def getValueAtPosition(self, position, value, context): 
        '''getValueAtPosition(self, position, value, context)
Arguments:
	[in]	position = float
	[out]	value = float
	[out]	context = MDGContext

Gets the value at position'''
        pass

    def setColorAtIndex(self, color, index): 
        '''setColorAtIndex(self, color, index)
Arguments:
	[in]	color = MColor
	[in]	index = int

Sets the color of a given entry'''
        pass

class MRichSelection:
    '''Selection list supporting soft selection and symmetry.'''
    def __init__(self):
        pass


    def getSymmetryMatrix(self, path, space, symmetryMatrix): 
        '''getSymmetryMatrix(self, path, space, symmetryMatrix)
Arguments:
	[in]	path = MDagPath
	[in]	space = MSpace.Space
	[out]	symmetryMatrix = MMatrix

Returns the symmetry matrix to use for the symmetric component
of the specified DAG object. This method handles any matrix space
conversions for you.'''
        pass

    def getSymmetry(self, symmetry): 
        '''getSymmetry(self, symmetry)
Arguments:
	[out]	symmetry = MSelectionList

Returns a copy of the symmetry component of the rich
selection.'''
        pass

    def getSelection(self, selection): 
        '''getSelection(self, selection)
Arguments:
	[out]	selection = MSelectionList

Returns a copy of the non-symmetry component of the rich
selection.'''
        pass

    def getSymmetryPlane(self, path, space, symmetryPlane): 
        '''getSymmetryPlane(self, path, space, symmetryPlane)
Arguments:
	[in]	path = MDagPath
	[in]	space = MSpace.Space
	[out]	symmetryPlane = MPlane

Returns the plane of symmetry. This can be used to enforce seam
weights in tools that support symmetry. Note that the direction of
the plane carries no significance (specifically, having a positive
offset from the plane does not imply a point is part of the
non-symmetric selection).'''
        pass

    def clear(self): 
        '''clear(self)
This method empties the rich selection.'''
        pass

class MSceneMessage:
    '''Scene messages.'''
    def __init__(self):
        pass


    def addCheckFileCallback(self, msg, func, clientData): 
        '''addCheckFileCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MCheckFileFunction
	[in]	clientData = void

This function adds a new callback for the specified scene
message. This callback has the option to abort the current
operation by setting the retCode parameter to false. The file
parameter stores the target file for the current file IO operation,
by modifying this file parameter the target file will be changed as
well.'''
        pass

    def kBeforePluginLoad(self):
        '''This is an enum of Message.
Description: Called prior to a plugin being loaded.
Value: 37'''
        pass

    def kBeforeSoftwareRender(self):
        '''This is an enum of Message.
Description: Called before a Software Render begins.
Value: 21'''
        pass

    def kBeforeImportReference(self):
        '''This is an enum of Message.
Description: Called before a File > ImportReference operation.
Value: 15'''
        pass

    def kBeforeNewCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > New operation, allows user to cancel
action.
Value: 28'''
        pass

    def kBeforeReferenceCheck(self):
        '''This is an enum of Message.
Description: Called prior to a File > CreateReference operation, allows
user to cancel action. Deprecated. Use
kBeforeCreateReferenceCheck.
Value: 36'''
        pass

    def kBeforeExportReference(self):
        '''This is an enum of Message.
Description: Called before a File > ExportReference operation.
Value: 17'''
        pass

    def kBeforeSaveCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Save operation, allows user to cancel
action.
Value: 30'''
        pass

    def kAfterPluginLoad(self):
        '''This is an enum of Message.
Description: Called after a plugin is loaded.
Value: 38'''
        pass

    def kBeforeUnloadReference(self):
        '''This is an enum of Message.
Description: Called before a File > UnloadReference operation.
Value: 19'''
        pass

    def kBeforeLoadReference(self):
        '''This is an enum of Message.
Description: Called before a File > LoadReference operation.
Value: 33'''
        pass

    def kAfterSoftwareFrameRender(self):
        '''This is an enum of Message.
Description: Called after each frame of a Software Render.
Value: 24'''
        pass

    def kAfterPluginUnload(self):
        '''This is an enum of Message.
Description: Called after a plugin is unloaded.
Value: 40'''
        pass

    def kAfterLoadReference(self):
        '''This is an enum of Message.
Description: Called after a File > LoadReference operation.
Value: 34'''
        pass

    def kBeforeReference(self):
        '''This is an enum of Message.
Description: Called before a File > Reference operation. Deprecated. Use
kBeforeCreateReference/kBeforeLoadReference.
Value: 11'''
        pass

    def kBeforeSave(self):
        '''This is an enum of Message.
Description: Called before a File > Save (or SaveAs) operation.
Value: 9'''
        pass

    def kBeforeExportCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Export operation, allows user to
cancel action.
Value: 32'''
        pass

    def kSoftwareRenderInterrupted(self):
        '''This is an enum of Message.
Description: Called when an interactive render is interrupted by the
user.
Value: 25'''
        pass

    def kAfterOpen(self):
        '''This is an enum of Message.
Description: Called after a File > Open operation.
Value: 6'''
        pass

    def kAfterExportReference(self):
        '''This is an enum of Message.
Description: Called after a File > ExportReference operation.
Value: 18'''
        pass

    def kAfterReference(self):
        '''This is an enum of Message.
Description: Called after a File > Reference operation. Deprecated. Use
kAfterCreateReference/kAfterLoadReference.
Value: 12'''
        pass

    def kAfterSave(self):
        '''This is an enum of Message.
Description: Called after a File > Save (or SaveAs) operation.
Value: 10'''
        pass

    def kBeforePluginUnload(self):
        '''This is an enum of Message.
Description: Called prior to a plugin being unloaded.
Value: 39'''
        pass

    def kBeforeLoadReferenceCheck(self):
        '''This is an enum of Message.
Description: Called before a File > LoadReference operation, allows user
to cancel action.
Value: 35'''
        pass

    def kBeforeOpen(self):
        '''This is an enum of Message.
Description: Called before a File > Open operation.
Value: 5'''
        pass

    def kBeforeImport(self):
        '''This is an enum of Message.
Description: Called before a File > Import operation.
Value: 3'''
        pass

    def kMayaExiting(self):
        '''This is an enum of Message.
Description: Called just before Maya exits.
Value: 27'''
        pass

    def kBeforeSoftwareFrameRender(self):
        '''This is an enum of Message.
Description: Called before each frame of a Software Render.
Value: 23'''
        pass

    def kBeforeCreateReferenceCheck(self):
        '''This is an enum of Message.
Description: Called prior to a File > CreateReference operation, allows
user to cancel action.
Value: 36'''
        pass

    def kBeforeOpenCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Open operation, allows user to cancel
action.
Value: 29'''
        pass

    def kAfterImportReference(self):
        '''This is an enum of Message.
Description: Called after a File > ImportReference operation.
Value: 16'''
        pass

    def kBeforeRemoveReference(self):
        '''This is an enum of Message.
Description: Called before a File > RemoveReference operation.
Value: 13'''
        pass

    def kAfterImport(self):
        '''This is an enum of Message.
Description: Called after a File > Import operation.
Value: 4'''
        pass

    def kLast(self):
        '''This is an enum of Message.
Description: Last value of the enum.
Value: 43'''
        pass

    def kAfterSoftwareRender(self):
        '''This is an enum of Message.
Description: Called after a Software Render ends.
Value: 22'''
        pass

    def kBeforeExport(self):
        '''This is an enum of Message.
Description: Called before a File > Export operation.
Value: 7'''
        pass

    def kBeforeCreateReference(self):
        '''This is an enum of Message.
Description: Called before a File > CreateReference operation.
Value: 41'''
        pass

    def kAfterRemoveReference(self):
        '''This is an enum of Message.
Description: Called after a File > RemoveReference operation.
Value: 14'''
        pass

    def kSceneUpdate(self):
        '''This is an enum of Message.
Description: Called after any operation that changes which files are
loaded.
Value: 0'''
        pass

    def kAfterExport(self):
        '''This is an enum of Message.
Description: Called after a File > Export operation.
Value: 8'''
        pass

    def kBeforeImportCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Import operation, allows user to
cancel action.
Value: 31'''
        pass

    def kAfterNew(self):
        '''This is an enum of Message.
Description: Called after a File > New operation.
Value: 2'''
        pass

    def kAfterCreateReference(self):
        '''This is an enum of Message.
Description: Called after a File > CreateReference operation.
Value: 42'''
        pass

    def kBeforeNew(self):
        '''This is an enum of Message.
Description: Called before a File > New operation.
Value: 1'''
        pass

    def kAfterUnloadReference(self):
        '''This is an enum of Message.
Description: Called after a File > UnloadReference operation.
Value: 20'''
        pass

    def kMayaInitialized(self):
        '''This is an enum of Message.
Description: Called on interactive or batch startup after
initialization.
Value: 26'''
        pass

    class Message:
        '''Non-functional class.  Values for this enum:
        kBeforePluginLoad
        kBeforeSoftwareRender
        kBeforeImportReference
        kBeforeNewCheck
        kBeforeReferenceCheck
        kBeforeExportReference
        kBeforeSaveCheck
        kAfterPluginLoad
        kBeforeUnloadReference
        kBeforeLoadReference
        kAfterSoftwareFrameRender
        kAfterPluginUnload
        kAfterLoadReference
        kBeforeReference
        kBeforeSave
        kBeforeExportCheck
        kSoftwareRenderInterrupted
        kAfterOpen
        kAfterExportReference
        kAfterReference
        kAfterSave
        kBeforePluginUnload
        kBeforeLoadReferenceCheck
        kBeforeOpen
        kBeforeImport
        kMayaExiting
        kBeforeSoftwareFrameRender
        kBeforeCreateReferenceCheck
        kBeforeOpenCheck
        kAfterImportReference
        kBeforeRemoveReference
        kAfterImport
        kLast
        kAfterSoftwareRender
        kBeforeExport
        kBeforeCreateReference
        kAfterRemoveReference
        kSceneUpdate
        kAfterExport
        kBeforeImportCheck
        kAfterNew
        kAfterCreateReference
        kBeforeNew
        kAfterUnloadReference
        kMayaInitialized
'''
        def __init__(self):
            pass

    def addCheckCallback(self, msg, func, clientData): 
        '''addCheckCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MCheckFunction
	[in]	clientData = void

This function adds a new callback for the specified scene
message and also has the option to abort the current operation by
return false through the return code parameter.'''
        pass

    def addStringArrayCallback(self, msg, func, clientData): 
        '''addStringArrayCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MStringArrayFunction
	[in]	clientData = void

Adds a new callback which takes a string array argument, in
addition to the usual clientData.'''
        pass

    def addCallback(self, msg, func, clientData): 
        '''addCallback(self, msg, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

Adds a new callback for the specified scene message.'''
        pass

class MScriptUtil:
    '''Utility class for working with pointers and references in Python.'''
    def __init__(self):
        pass


    def setDoubleArray(self, index, value, var): 
        '''setDoubleArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = double
	[in]	index = int
	[in]	value = double

Set a double value in an array. Ensure that index is valid
before calling this method.'''
        pass

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

'''
        pass

    def createMatrixFromList(self, pythonList, matrix): 
        '''createMatrixFromList(self, pythonList, matrix) -> bool

Arguments:
	[in]	pythonList = void
	[in]	matrix = MMatrix

Create an  MMatrix 
object from a list of 16 doubles. The pythonList parameter must be
a python list (1.0,2.0,...).'''
        pass

    def createFromInt(self, x, y, z, w): 
        '''createFromInt(self, x, y, z, w)
Arguments:
	[in]	x = int
	[in]	y = int
	[in]	z = int
	[in]	w = int

Create this object from 4 integers. Data already stored in this
class will be cleared.'''
        pass

    def getInt3ArrayItem(self, var, r, c): 
        '''getInt3ArrayItem(self, var, r, c) -> int
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int

Get a value from the three dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def asShort(self): 
        '''asShort(self) -> short

'''
        pass

    def setCharArray(self, index, value, var): 
        '''setCharArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = char
	[in]	index = int
	[in]	value = int

Set a char value in an array. Ensure that index is valid before
calling this method.'''
        pass

    def getUint4ArrayItem(self, var, r, c): 
        '''getUint4ArrayItem(self, var, r, c) -> int
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int

Get a value from the four dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def getCharArrayItem(self, var, index): 
        '''getCharArrayItem(self, var, index) -> int
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = char
	[in]	index = int

Get a char value from an array. Ensure that index is valid
before calling this method.'''
        pass

    def getUint(self, var): 
        '''getUint(self, var) -> int

Arguments:
	[out]	var = int

Get the values of an unsigned int reference.'''
        pass

    def setUint(self, value, var): 
        '''setUint(self, value, var)
Arguments:
	[out]	var = int
	[in]	value = int

Set an unsigned integer reference value.'''
        pass

    def asFloat(self): 
        '''asFloat(self) -> float

'''
        pass

    def setShortArray(self, index, value, var): 
        '''setShortArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = short
	[in]	index = int
	[in]	value = int

Set a short value in an array. Ensure that index is valid before
calling this method.'''
        pass

    def asShortPtr(self): 
        '''asShortPtr(self) -> short*

'''
        pass

    def createIntArrayFromList(self, pythonList, array): 
        '''createIntArrayFromList(self, pythonList, array) -> bool

Arguments:
	[in]	pythonList = void
	[in]	array = MIntArray

Create an  MIntArray  object from a python
list. The pythonList parameter must be a python list
(1.0,2.0,...).'''
        pass

    def asInt2Ptr(self): 
        '''asInt2Ptr(self) -> MScriptUtil.Mint2*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def setShort2ArrayItem(self, var, r, c, value): 
        '''setShort2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = short(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = short

Set a value in the two dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def setDouble3ArrayItem(self, var, r, c, value): 
        '''setDouble3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = double(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = double

Set a value in the three dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def createFloatArrayFromList(self, pythonList, array): 
        '''createFloatArrayFromList(self, pythonList, array) -> bool

Arguments:
	[in]	pythonList = void
	[in]	array = MFloatArray

Create an  MFloatArray  object from a python
list. The pythonList parameter must be a python list
(1.0,2.0,...).'''
        pass

    def setFloat(self, value, var): 
        '''setFloat(self, value, var)
Arguments:
	[out]	var = float
	[in]	value = double

Set a float reference value.'''
        pass

    def setFloatArray(self, index, value, var): 
        '''setFloatArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = float
	[in]	index = int
	[in]	value = double

Set a float value in an array. Ensure that index is valid before
calling this method.'''
        pass

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

'''
        pass

    def asIntPtr(self): 
        '''asIntPtr(self) -> int*

'''
        pass

    def createFloatMatrixFromList(self, pythonList, matrix): 
        '''createFloatMatrixFromList(self, pythonList, matrix) -> bool

Arguments:
	[in]	pythonList = void
	[in]	matrix = MFloatMatrix

Create an  MFloatMatrix 
object from a list of 16 doubles. The pythonList parameter must be
a python list (1.0,2.0,...).'''
        pass

    def setUchar(self, value, var): 
        '''setUchar(self, value, var)
Arguments:
	[out]	var = char
	[in]	value = int

Set an unsigned char reference value.'''
        pass

    def asFloat3Ptr(self): 
        '''asFloat3Ptr(self) -> MScriptUtil.Mfloat3*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def asUint2Ptr(self): 
        '''asUint2Ptr(self) -> MScriptUtil.Muint2*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def setDouble2ArrayItem(self, var, r, c, value): 
        '''setDouble2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = double(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = double

Set a value in the two dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def setBool(self, value, var): 
        '''setBool(self, value, var)
Arguments:
	[out]	var = bool
	[in]	value = int

Set a bool reference value.'''
        pass

    def setFloat2ArrayItem(self, var, r, c, value): 
        '''setFloat2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = float(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = float

Set a value in the two dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def getFloatArrayItem(self, var, index): 
        '''getFloatArrayItem(self, var, index) -> double
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = float
	[in]	index = int

Get a float value from an array. Ensure that index is valid
before calling this method.'''
        pass

    def setUintArray(self, index, value, var): 
        '''setUintArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = int
	[in]	index = int
	[in]	value = int

Set an unsigned integer value in an array. Ensure that index is
valid before calling this method.'''
        pass

    def getUint3ArrayItem(self, var, r, c): 
        '''getUint3ArrayItem(self, var, r, c) -> int
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int

Get a value from the three dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def getShortArrayItem(self, var, index): 
        '''getShortArrayItem(self, var, index) -> int
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = short
	[in]	index = int

Get a short value from an array. Ensure that index is valid
before calling this method.'''
        pass

    def asFloat4Ptr(self): 
        '''asFloat4Ptr(self) -> MScriptUtil.Mfloat4*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

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

'''
        pass

    def getDouble2ArrayItem(self, var, r, c): 
        '''getDouble2ArrayItem(self, var, r, c) -> double
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = double(*)2
	[in]	r = int
	[in]	c = int

Get a value from the two dimensional array. Ensure that indicies
are valid before calling this method.'''
        pass

    def getFloat4ArrayItem(self, var, r, c): 
        '''getFloat4ArrayItem(self, var, r, c) -> float
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = float(*)4
	[in]	r = int
	[in]	c = int

Get a value from the four dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def setInt2ArrayItem(self, var, r, c, value): 
        '''setInt2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = int

Set a value in the two dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def getUintArrayItem(self, var, index): 
        '''getUintArrayItem(self, var, index) -> int
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = int
	[in]	index = int

Get an unsigned value from an array. Ensure that index is valid
before calling this method.'''
        pass

    def setInt3ArrayItem(self, var, r, c, value): 
        '''setInt3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = int

Set a value in the three dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def getDouble3ArrayItem(self, var, r, c): 
        '''getDouble3ArrayItem(self, var, r, c) -> double
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = double(*)3
	[in]	r = int
	[in]	c = int

Get a value from the three dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def getInt4ArrayItem(self, var, r, c): 
        '''getInt4ArrayItem(self, var, r, c) -> int
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int

Get a value from the four dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def createFromList(self, pythonList, length): 
        '''createFromList(self, pythonList, length) -> bool

Arguments:
	[in]	pythonList = void
	[in]	length = int

'''
        pass

    def getShort4ArrayItem(self, var, r, c): 
        '''getShort4ArrayItem(self, var, r, c) -> short
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = short(*)4
	[in]	r = int
	[in]	c = int

Get a value from the four dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def asDoublePtr(self): 
        '''asDoublePtr(self) -> double*

'''
        pass

    def getFloat(self, var): 
        '''getFloat(self, var) -> double

Arguments:
	[out]	var = float

Get the values of a float reference.'''
        pass

    def getBoolArrayItem(self, var, index): 
        '''getBoolArrayItem(self, var, index) -> int
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = bool
	[in]	index = int

Get a bool value from an array. Ensure that index is valid
before calling this method.'''
        pass

    def asUintPtr(self): 
        '''asUintPtr(self) -> int*

'''
        pass

    def setUint4ArrayItem(self, var, r, c, value): 
        '''setUint4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = int

Set a value in the four dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def setShort4ArrayItem(self, var, r, c, value): 
        '''setShort4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = short(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = short

Set a value in the two dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def asInt4Ptr(self): 
        '''asInt4Ptr(self) -> MScriptUtil.Mint4*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def getUcharArrayItem(self, var, index): 
        '''getUcharArrayItem(self, var, index) -> int
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = char
	[in]	index = int

Get an unsigned char value from an array. Ensure that index is
valid before calling this method.'''
        pass

    def asUint3Ptr(self): 
        '''asUint3Ptr(self) -> MScriptUtil.Muint3*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def setDouble4ArrayItem(self, var, r, c, value): 
        '''setDouble4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = double(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = double

Set a value in the four dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def setInt4ArrayItem(self, var, r, c, value): 
        '''setInt4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = int

Set a value in the four dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def getDouble4ArrayItem(self, var, r, c): 
        '''getDouble4ArrayItem(self, var, r, c) -> double
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = double(*)4
	[in]	r = int
	[in]	c = int

Get a value from the four dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def getBool(self, var): 
        '''getBool(self, var) -> int

Arguments:
	[in]	var = bool

'''
        pass

    def asShort3Ptr(self): 
        '''asShort3Ptr(self) -> MScriptUtil.Mshort3*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def getInt(self, var): 
        '''getInt(self, var) -> int

Arguments:
	[out]	var = int

Get the value of an integer reference.'''
        pass

    def getShort3ArrayItem(self, var, r, c): 
        '''getShort3ArrayItem(self, var, r, c) -> short
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = short(*)3
	[in]	r = int
	[in]	c = int

Get a value from the three dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def getFloat3ArrayItem(self, var, r, c): 
        '''getFloat3ArrayItem(self, var, r, c) -> float
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = float(*)3
	[in]	r = int
	[in]	c = int

Get a value from the three dimensional array. Ensure that
indicies are valid before calling this method.'''
        pass

    def getDouble(self, var): 
        '''getDouble(self, var) -> double

Arguments:
	[out]	var = double

Get the value of a double reference.'''
        pass

    def setInt(self, value, var): 
        '''setInt(self, value, var)
Arguments:
	[out]	var = int
	[in]	value = int

Set an integer reference value.'''
        pass

    def asFloat2Ptr(self): 
        '''asFloat2Ptr(self) -> MScriptUtil.Mfloat2*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

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

'''
        pass

    def getChar(self, var): 
        '''getChar(self, var) -> int

Arguments:
	[in]	var = char

Get the value of a char reference.'''
        pass

    def asDouble4Ptr(self): 
        '''asDouble4Ptr(self) -> MScriptUtil.Mdouble4*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def getUchar(self, var): 
        '''getUchar(self, var) -> int

Arguments:
	[in]	var = char

Get the value of an unsigned char reference.'''
        pass

    def setFloat3ArrayItem(self, var, r, c, value): 
        '''setFloat3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = float(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = float

Set a value in the three dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def setUcharArray(self, index, value, var): 
        '''setUcharArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = char
	[in]	index = int
	[in]	value = int

Set an unsigned char value in an array. Ensure that index is
valid before calling this method.'''
        pass

    def setFloat4ArrayItem(self, var, r, c, value): 
        '''setFloat4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = float(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = float

Set a value in the four dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def asBoolPtr(self): 
        '''asBoolPtr(self) -> bool*

'''
        pass

    def asInt3Ptr(self): 
        '''asInt3Ptr(self) -> MScriptUtil.Mint3*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def getShort(self, var): 
        '''getShort(self, var) -> int

Arguments:
	[in]	var = short

Get the value of a short reference.'''
        pass

    def getFloat2ArrayItem(self, var, r, c): 
        '''getFloat2ArrayItem(self, var, r, c) -> float
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = float(*)2
	[in]	r = int
	[in]	c = int

Get a value from the two dimensional array. Ensure that indicies
are valid before calling this method.'''
        pass

    def asShort2Ptr(self): 
        '''asShort2Ptr(self) -> MScriptUtil.Mshort2*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def asFloatPtr(self): 
        '''asFloatPtr(self) -> float*

'''
        pass

    def asDouble3Ptr(self): 
        '''asDouble3Ptr(self) -> MScriptUtil.Mdouble3*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def asUint4Ptr(self): 
        '''asUint4Ptr(self) -> MScriptUtil.Muint4*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def setUint3ArrayItem(self, var, r, c, value): 
        '''setUint3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = int

Set a value in the three dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

    def asDouble2Ptr(self): 
        '''asDouble2Ptr(self) -> MScriptUtil.Mdouble2*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

    def getDoubleArrayItem(self, var, index): 
        '''getDoubleArrayItem(self, var, index) -> double
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = double
	[in]	index = int

Get a double value from an array. Ensure that index is valid
before calling this method.'''
        pass

    def setBoolArray(self, index, value, var): 
        '''setBoolArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = bool
	[in]	index = int
	[in]	value = int

Set a bool value in an array. Ensure that index is valid before
calling this method.'''
        pass

    def getUint2ArrayItem(self, var, r, c): 
        '''getUint2ArrayItem(self, var, r, c) -> int
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int

Get a value from the two dimensional array. Ensure that indicies
are valid before calling this method.'''
        pass

    def setShort(self, value, var): 
        '''setShort(self, value, var)
Arguments:
	[out]	var = short
	[in]	value = int

Set a short reference value.'''
        pass

    def setIntArray(self, index, value, var): 
        '''setIntArray(self, index, value, var) -> bool
Returns: Returns:
True on success, false otherwise.

Arguments:
	[out]	var = int
	[in]	index = int
	[in]	value = int

Set an integer value in an array. Ensure that index is valid
before calling this method.'''
        pass

    def getIntArrayItem(self, var, index): 
        '''getIntArrayItem(self, var, index) -> int
Returns: Returns:
Value of the element.

Arguments:
	[in]	var = int
	[in]	index = int

Get a int value from an array. Ensure that index is valid before
calling this method.'''
        pass

    def getShort2ArrayItem(self, var, r, c): 
        '''getShort2ArrayItem(self, var, r, c) -> short
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = short(*)2
	[in]	r = int
	[in]	c = int

Get a value from the two dimensional array. Ensure that indicies
are valid before calling this method.'''
        pass

    def asShort4Ptr(self): 
        '''asShort4Ptr(self) -> MScriptUtil.Mshort4*

Copy the data to a temporary array of the right type and return
its address. Ensure that this object has been created with
sufficient data.'''
        pass

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

'''
        pass

    def getInt2ArrayItem(self, var, r, c): 
        '''getInt2ArrayItem(self, var, r, c) -> int
Returns: Returns:
Value of the element: var[r][c]

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int

Get a value from the two dimensional array. Ensure that indicies
are valid before calling this method.'''
        pass

    def createFromDouble(self, x, y, z, w): 
        '''createFromDouble(self, x, y, z, w)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double

Create this object from 4 doubles. Data already stored in this
class will be cleared.'''
        pass

    def setDouble(self, value, var): 
        '''setDouble(self, value, var)
Arguments:
	[out]	var = double
	[in]	value = double

Set a double reference value.'''
        pass

    def setChar(self, value, var): 
        '''setChar(self, value, var)
Arguments:
	[out]	var = char
	[in]	value = int

Set a char reference value.'''
        pass

    def setUint2ArrayItem(self, var, r, c, value): 
        '''setUint2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = int

Set a value in the two dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

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

'''
        pass

    def setShort3ArrayItem(self, var, r, c, value): 
        '''setShort3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = short(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = short

Set a value in the three dimensional array. Ensure that indices
are valid before calling this method.'''
        pass

class MSelectionList:
    '''A list of MObjects.'''
    def __init__(self):
        pass


    def toggle(self, item, component): 
        '''toggle(self, item, component)
Arguments:
	[in]	item = MDagPath
	[in]	component = MObject

Removes those components of the given selection item which are
on the selection list, and adds those parts which are not. This
method does nothing if no components are provided.'''
        pass

    def getSelectionStrings(self, index, array): 
        '''getSelectionStrings(self, index, array)
Arguments:
	[in]	index = int
	[out]	array = MStringArray

Gets the string representation of the given item in the
selection list. The strings will be in the format used by the
scripting language. More than one string will be returned in the
case that the item in the selection list has a component that that
contains elements that are not contiguous (eg CV's 2 and 8 are
selected on a surface).'''
        pass

    def hasItemPartly(self, item, component): 
        '''hasItemPartly(self, item, component) -> bool
Returns: Returns:
true if at least one of the components in this list, false
otherwise

Arguments:
	[in]	item = MDagPath
	[in]	component = MObject

This method differs from  hasItem  in that it determines
whether or not  at least one  of the components of the the
given DAG object are in this selection list. This method is only
applicable when multiple components are provided.'''
        pass

    def clear(self): 
        '''clear(self)
This method empties the selection list.'''
        pass

    def getDagPath(self, index, dagPath, component): 
        '''getDagPath(self, index, dagPath, component)
Arguments:
	[in]	index = int
	[out]	dagPath = MDagPath
	[out]	component = MObject

Get the dag path and component (may be NULL) of the given
element of the selection list.'''
        pass

    def add(self, plug, mergeWithExisting): 
        '''add(self, plug, mergeWithExisting)
Arguments:
	[in]	plug = MPlug
	[in]	mergeWithExisting = bool

Add the specified plug to the selection list.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Removes the item at the given index from the list.'''
        pass

    def replace(self, index, plug): 
        '''replace(self, index, plug)
Arguments:
	[in]	index = int
	[in]	plug = MPlug

Remove the item at the given index in the list and replace it
with the given plug. The given index must not be greater than the
current number of items on the list.'''
        pass

    def merge(self, item, component, strategy): 
        '''merge(self, item, component, strategy)
Arguments:
	[in]	item = MDagPath
	[in]	component = MObject
	[in]	strategy = MSelectionList.MergeStrategy

Merge the given DAG object into the selection list.'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Returns:
Number of items in the list

This method returns the number of selection items in the
list.'''
        pass

    def isEmpty(self): 
        '''isEmpty(self) -> bool
Returns: Returns:
true if the list is empty, false otherwise.

Specifies whether or not the selection list contains any
items.'''
        pass

    def kMergeNormal(self):
        '''This is an enum of MergeStrategy.
Description: If the object is not already on the list, add it.
Value: 0'''
        pass

    def kRemoveFromList(self):
        '''This is an enum of MergeStrategy.
Description: Remove the object from the list.
Value: 2'''
        pass

    def kXORWithList(self):
        '''This is an enum of MergeStrategy.
Description: Exclusive OR: if the object is already on the list, remove it,
otherwise add it.
Value: 1'''
        pass

    class MergeStrategy:
        '''Non-functional class.  Values for this enum:
        kMergeNormal
        kRemoveFromList
        kXORWithList
'''
        def __init__(self):
            pass

    def getPlug(self, index, plug): 
        '''getPlug(self, index, plug)
Arguments:
	[in]	index = int
	[out]	plug = MPlug

Get the plug at the specified index of the selection list.'''
        pass

    def hasItem(self, plug): 
        '''hasItem(self, plug) -> bool
Returns: Returns:
true if the plug is in this list, false otherwise

Arguments:
	[in]	plug = MPlug

Determines whether or not the given plug is in this selection
list.'''
        pass

    def getDependNode(self, index, depNode): 
        '''getDependNode(self, index, depNode)
Arguments:
	[in]	index = int
	[out]	depNode = MObject

Get a handle for the dependency node of the given element of the
selection list.'''
        pass

class MSelectionMask:
    '''Manage what is selectable in Maya. (OpenMaya) (OpenMaya.py).'''
    def __init__(self):
        pass


    def addMask(self, selType): 
        '''addMask(self, selType)
Arguments:
	[in]	selType = MSelectionMask.SelectionType

Add the specified selection type to this mask.'''
        pass

    def setMask(self, mask): 
        '''setMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask

Sets the selection type for this mask to the selection type of
the specified mask.'''
        pass

    def intersects(self, mask): 
        '''intersects(self, mask) -> bool
Returns: Returns:


true the specified selectin mask is contained in this
mask
false the specified selectin mask is not in this
mask

Arguments:
	[in]	mask = MSelectionMask

Returns true if the specified selection mask is contained within
this selection mask.'''
        pass

    def kSelectMeshVerts(self):
        '''This is an enum of SelectionType.
Description: 
Value: 33'''
        pass

    def kSelectMeshFaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 36'''
        pass

    def kSelectSubdivMeshMaps(self):
        '''This is an enum of SelectionType.
Description: 
Value: 76'''
        pass

    def kSelectOrientationLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 23'''
        pass

    def kSelectCollisionModels(self):
        '''This is an enum of SelectionType.
Description: 
Value: 21'''
        pass

    def kSelectMeshComponents(self):
        '''This is an enum of SelectionType.
Description: 
Value: 45'''
        pass

    def kSelectNRigids(self):
        '''This is an enum of SelectionType.
Description: 
Value: 81'''
        pass

    def kSelectRigidConstraints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 20'''
        pass

    def kSelectCurveKnots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 47'''
        pass

    def kSelectEmitters(self):
        '''This is an enum of SelectionType.
Description: 
Value: 16'''
        pass

    def kSelectAnimKeyframes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 64'''
        pass

    def kSelectPointsOnCurvesForGravity(self):
        '''This is an enum of SelectionType.
Description: 
Value: 73'''
        pass

    def kSelectIsoparms(self):
        '''This is an enum of SelectionType.
Description: 
Value: 52'''
        pass

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

    def kSelectMeshLines(self):
        '''This is an enum of SelectionType.
Description: 
Value: 44'''
        pass

    def kSelectParticles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 56'''
        pass

    def kSelectTextures(self):
        '''This is an enum of SelectionType.
Description: 
Value: 25'''
        pass

    def kSelectSurfaceRange(self):
        '''This is an enum of SelectionType.
Description: 
Value: 50'''
        pass

    def kSelectObjectsMask(self):
        '''This is an enum of SelectionType.
Description: 
Value: 29'''
        pass

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

    def kSelectSketchPlanes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 14'''
        pass

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

    def kSelectSubdivMeshPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 37'''
        pass

    def kSelectParticleShapes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 15'''
        pass

    def kSelectDynamicConstraints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 82'''
        pass

    def kSelectAnimAny(self):
        '''This is an enum of SelectionType.
Description: 
Value: 68'''
        pass

    def kSelectMeshUVs(self):
        '''This is an enum of SelectionType.
Description: 
Value: 40'''
        pass

    def kSelectFacets(self):
        '''This is an enum of SelectionType.
Description: 
Value: 43'''
        pass

    def kSelectGuideLines(self):
        '''This is an enum of SelectionType.
Description: 
Value: 71'''
        pass

    def kSelectTemplates(self):
        '''This is an enum of SelectionType.
Description: 
Value: 69'''
        pass

    def kSelectHairSystems(self):
        '''This is an enum of SelectionType.
Description: 
Value: 78'''
        pass

    def kSelectFields(self):
        '''This is an enum of SelectionType.
Description: 
Value: 17'''
        pass

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

    def kSelectCVs(self):
        '''This is an enum of SelectionType.
Description: 
Value: 30'''
        pass

    def kSelectManipulators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 70'''
        pass

    def kSelectPivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 60'''
        pass

    def kSelectCurves(self):
        '''This is an enum of SelectionType.
Description: 
Value: 26'''
        pass

    def kSelectObjectGroups(self):
        '''This is an enum of SelectionType.
Description: 
Value: 75'''
        pass

    def kSelectSurfaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 27'''
        pass

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

    def kSelectXYZLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 22'''
        pass

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

    def kSelectJointPivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 57'''
        pass

    def kSelectCurveParmPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 46'''
        pass

    def kSelectNurbsSurfaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 11'''
        pass

    def kSelectSurfaceKnots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 49'''
        pass

    def kSelectUVLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 24'''
        pass

    def kSelectSurfaceParmPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 48'''
        pass

    def kSelectSelectHandles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 61'''
        pass

    def kSelectPointsForGravity(self):
        '''This is an enum of SelectionType.
Description: 
Value: 72'''
        pass

    def kSelectNurbsCurves(self):
        '''This is an enum of SelectionType.
Description: 
Value: 10'''
        pass

    def kSelectPPStrokes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 54'''
        pass

    def kSelectMeshes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 12'''
        pass

    def kSelectSubdivMeshEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 38'''
        pass

    def kSelectNCloths(self):
        '''This is an enum of SelectionType.
Description: 
Value: 80'''
        pass

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

    def kSelectRigidBodies(self):
        '''This is an enum of SelectionType.
Description: 
Value: 19'''
        pass

    def kSelectVertices(self):
        '''This is an enum of SelectionType.
Description: 
Value: 41'''
        pass

    def kSelectSubdiv(self):
        '''This is an enum of SelectionType.
Description: 
Value: 13'''
        pass

    def kSelectFluids(self):
        '''This is an enum of SelectionType.
Description: 
Value: 77'''
        pass

    def kSelectSprings(self):
        '''This is an enum of SelectionType.
Description: 
Value: 18'''
        pass

    def kSelectScalePivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 58'''
        pass

    def kSelectMeshFreeEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 35'''
        pass

    def kSelectAnimInTangents(self):
        '''This is an enum of SelectionType.
Description: 
Value: 65'''
        pass

    def kSelectAnimMask(self):
        '''This is an enum of SelectionType.
Description: 
Value: 67'''
        pass

    def kSelectFollicles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 79'''
        pass

    def kSelectMeshEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 34'''
        pass

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

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

    def kSelectEditPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 32'''
        pass

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

    def kSelectNParticles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 83'''
        pass

    def kSelectPointsOnSurfacesForGravity(self):
        '''This is an enum of SelectionType.
Description: 
Value: 74'''
        pass

    def kSelectHulls(self):
        '''This is an enum of SelectionType.
Description: 
Value: 31'''
        pass

    def kSelectSurfaceEdge(self):
        '''This is an enum of SelectionType.
Description: 
Value: 51'''
        pass

    def kSelectLatticePoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 55'''
        pass

    def kSelectCurvesOnSurfaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 53'''
        pass

    def kSelectAnimOutTangents(self):
        '''This is an enum of SelectionType.
Description: 
Value: 66'''
        pass

    def kSelectSubdivMeshFaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 39'''
        pass

    def kSelectComponentsMask(self):
        '''This is an enum of SelectionType.
Description: 
Value: 62'''
        pass

    def kSelectRotatePivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 59'''
        pass

    def kSelectEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 42'''
        pass

    def kSelectAnimCurves(self):
        '''This is an enum of SelectionType.
Description: 
Value: 63'''
        pass

    def kSelectLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 28'''
        pass

    class SelectionType:
        '''Non-functional class.  Values for this enum:
        kSelectMeshVerts
        kSelectMeshFaces
        kSelectSubdivMeshMaps
        kSelectOrientationLocators
        kSelectCollisionModels
        kSelectMeshComponents
        kSelectNRigids
        kSelectRigidConstraints
        kSelectCurveKnots
        kSelectEmitters
        kSelectAnimKeyframes
        kSelectPointsOnCurvesForGravity
        kSelectIsoparms
        kSelectJoints
        kSelectMeshLines
        kSelectParticles
        kSelectTextures
        kSelectSurfaceRange
        kSelectObjectsMask
        kSelectIkHandles
        kSelectSketchPlanes
        kSelectLocalAxis
        kSelectSubdivMeshPoints
        kSelectParticleShapes
        kSelectDynamicConstraints
        kSelectAnimAny
        kSelectMeshUVs
        kSelectFacets
        kSelectGuideLines
        kSelectTemplates
        kSelectHairSystems
        kSelectFields
        kSelectLights
        kSelectCVs
        kSelectManipulators
        kSelectPivots
        kSelectCurves
        kSelectObjectGroups
        kSelectSurfaces
        kSelectLattices
        kSelectXYZLocators
        kSelectCameras
        kSelectJointPivots
        kSelectCurveParmPoints
        kSelectNurbsSurfaces
        kSelectSurfaceKnots
        kSelectUVLocators
        kSelectSurfaceParmPoints
        kSelectSelectHandles
        kSelectPointsForGravity
        kSelectNurbsCurves
        kSelectPPStrokes
        kSelectMeshes
        kSelectSubdivMeshEdges
        kSelectNCloths
        kSelectClusters
        kSelectRigidBodies
        kSelectVertices
        kSelectSubdiv
        kSelectFluids
        kSelectSprings
        kSelectScalePivots
        kSelectMeshFreeEdges
        kSelectAnimInTangents
        kSelectAnimMask
        kSelectFollicles
        kSelectMeshEdges
        kSelectSculpts
        kSelectHandles
        kSelectEditPoints
        kSelectIkEndEffectors
        kSelectNParticles
        kSelectPointsOnSurfacesForGravity
        kSelectHulls
        kSelectSurfaceEdge
        kSelectLatticePoints
        kSelectCurvesOnSurfaces
        kSelectAnimOutTangents
        kSelectSubdivMeshFaces
        kSelectComponentsMask
        kSelectRotatePivots
        kSelectEdges
        kSelectAnimCurves
        kSelectLocators
'''
        def __init__(self):
            pass

class MSpace:
    '''Space transformation identifiers.There are four spaces in which to apply a transformation.'''
    def __init__(self):
        pass


    def kInvalid(self):
        '''This is an enum of Space.
Description: Invalid value.
Value: 0'''
        pass

    def kLast(self):
        '''This is an enum of Space.
Description: Last value, used for counting.
Value: 5'''
        pass

    def kPreTransform(self):
        '''This is an enum of Space.
Description: Pre-transform matrix (geometry).
Value: 2'''
        pass

    def kTransform(self):
        '''This is an enum of Space.
Description: Transform matrix (relative) space.
Value: 1'''
        pass

    def kPostTransform(self):
        '''This is an enum of Space.
Description: Post-transform matrix (world) space.
Value: 3'''
        pass

    def kWorld(self):
        '''This is an enum of Space.
Description: transform in world space.
Value: 4'''
        pass

    def kObject(self):
        '''This is an enum of Space.
Description: Same as pre-transform space.
Value: 2'''
        pass

    class Space:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kLast
        kPreTransform
        kTransform
        kPostTransform
        kWorld
        kObject
'''
        def __init__(self):
            pass

class MStatus:
    '''Manipulate Maya Status codes.'''
    def __init__(self):
        pass


    def set(self, status, statusCode, internalStatusCode): 
        '''set(self, status, statusCode, internalStatusCode)
Arguments:
	[in]	status = bool
	[in]	statusCode = char
	[in]	internalStatusCode = char

Internal use only.'''
        pass

    def perror(self, preString): 
        '''perror(self, preString)
Arguments:
	[in]	preString = MString

The second version of the  perror() 
method. This method takes a reference to a  MString  as
the parameter. It prints the error string preceded by the string
supplied by the user to the standard error stream.'''
        pass

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

This method returns the internal error message as a  MString  object.'''
        pass

    def clear(self): 
        '''clear(self)
Clear error codes from the  MStatus  instance. After this
call, it will behave as if it contained  MS::kSuccess . 
  Reprocessed example '''
        pass

    def setSuccess(self): 
        '''setSuccess(self)
'''
        pass

    def kLicenseFailure(self):
        '''This is an enum of MStatusCode.
Description: Application is not licensed for the attempted operation.
Value: 4'''
        pass

    def kUnknownParameter(self):
        '''This is an enum of MStatusCode.
Description: Returned by
Value: 5'''
        pass

    def kFailure(self):
        '''This is an enum of MStatusCode.
Description: The operation failed.
Value: 1'''
        pass

    def kInvalidParameter(self):
        '''This is an enum of MStatusCode.
Description: An invalid parameter was provided.
Value: 3'''
        pass

    def kSuccess(self):
        '''This is an enum of MStatusCode.
Description: The operation was successful.
Value: 0'''
        pass

    def kEndOfFile(self):
        '''This is an enum of MStatusCode.
Description: Not currently used.
Value: 8'''
        pass

    def kInsufficientMemory(self):
        '''This is an enum of MStatusCode.
Description: The operation failed due to insufficient memory.
Value: 2'''
        pass

    def kNotFound(self):
        '''This is an enum of MStatusCode.
Description: Not currently used.
Value: 7'''
        pass

    def kNotImplemented(self):
        '''This is an enum of MStatusCode.
Description: Not currently used.
Value: 6'''
        pass

    class MStatusCode:
        '''Non-functional class.  Values for this enum:
        kLicenseFailure
        kUnknownParameter
        kFailure
        kInvalidParameter
        kSuccess
        kEndOfFile
        kInsufficientMemory
        kNotFound
        kNotImplemented
'''
        def __init__(self):
            pass

    def bool(self): 
        '''bool(self) -> MStatus.operator

'''
        pass

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

Determines whether there is an error.'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool
Returns: Returns:


true the object does not have the given detailed status
code.
false the object has the given detailed status
code.

Arguments:
	[in]	rhs = MStatus.MStatusCode

The not equal operator that takes a  MStatus::MStatusCode .'''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool
Returns: Returns:


true the object has the given detailed status code.
false the object does not have the given detailed status
code.

Arguments:
	[in]	rhs = MStatus.MStatusCode

The equivalence operator that takes a  MStatus::MStatusCode .'''
        pass

    def statusCode(self): 
        '''statusCode(self) -> MStatus.MStatusCode

Retrieve the type of error that occurred, as specified in the
 MStatusCode  enumeration.'''
        pass

class MStreamUtils:
    '''Stream functionality.'''
    def __init__(self):
        pass


    def writeCharBuffer(self, outarg, value, binary): 
        '''writeCharBuffer(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = char
	[in]	binary = bool

This method is used to write out a "const char*" value to an
ostream.'''
        pass

    def writeChar(self, outarg, value, binary): 
        '''writeChar(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = char
	[in]	binary = bool

This method is used to write out a "char" value to an
ostream.'''
        pass

    def readInt(self, inarg, value, binary): 
        '''readInt(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = int
	[in]	binary = bool

This method is used to read a "int" binary value from an
istream.'''
        pass

    def readFloat(self, inarg, value, binary): 
        '''readFloat(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = float
	[in]	binary = bool

This method is used to read a "float" binary value from an
istream.'''
        pass

    def writeDouble(self, outarg, value, binary): 
        '''writeDouble(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = double
	[in]	binary = bool

This method is used to write out a "double" value to an
ostream.'''
        pass

    def readCharBuffer(self, inarg, value, length, binary): 
        '''readCharBuffer(self, inarg, value, length, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = char
	[in]	length = int
	[in]	binary = bool

This method is used to read a "char*" binary value from an
istream.'''
        pass

    def stdErrorStream(self): 
        '''stdErrorStream(self) -> std.ostream&

'''
        pass

    def writeFloat(self, outarg, value, binary): 
        '''writeFloat(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = float
	[in]	binary = bool

This method is used to write out a "float" value to an
ostream.'''
        pass

    def stdOutStream(self): 
        '''stdOutStream(self) -> std.ostream&

'''
        pass

    def writeInt(self, outarg, value, binary): 
        '''writeInt(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = int
	[in]	binary = bool

This method is used to write out a "int" value to an
ostream.'''
        pass

    def readDouble(self, inarg, value, binary): 
        '''readDouble(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = double
	[in]	binary = bool

This method is used to read a "double" binary value from an
istream.'''
        pass

    def readChar(self, inarg, value, binary): 
        '''readChar(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = char
	[in]	binary = bool

This method is used to read a "char" binary value from an
istream.'''
        pass

class MSyntax:
    '''Syntax for Commands.  and  are
incompatible and must not be combined in the syntax definition of a
command. If an attempt is made to do so, neither command arguments
or objects will be accessible via the MArgDatabase or MArgParser classes.'''
    def __init__(self):
        pass


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

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

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

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

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

    class MObjectFormat:
        '''Non-functional class.  Values for this enum:
        kInvalidObjectFormat
        kNone
        kLastObjectFormat
        kStringObjects
        kSelectionList
'''
        def __init__(self):
            pass

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

Returns whether or not the command supports the query flag
("-q").'''
        pass

    def makeFlagQueryWithFullArgs(self, flag, queryArgsAreOptional): 
        '''makeFlagQueryWithFullArgs(self, flag, queryArgsAreOptional)
Arguments:
	[in]	flag = char
	[in]	queryArgsAreOptional = bool

Specifies that the given flag will require all of its arguments
in query mode. Usually flags do not take arguments in query mode,
since you are getting values instead of setting them. However,
sometimes it is necessary to take arguments on a flag to allow the
user to provide information which will help specify the scope of a
query.'''
        pass

    def addFlag(self, shortName, longName, argType1, argType2, argType3, argType4, argType5, argType6): 
        '''addFlag(self, shortName, longName, argType1, argType2, argType3, argType4, argType5, argType6)
Arguments:
	[in]	shortName = char
	[in]	longName = char
	[in]	argType1 = MSyntax.MArgType
	[in]	argType2 = MSyntax.MArgType
	[in]	argType3 = MSyntax.MArgType
	[in]	argType4 = MSyntax.MArgType
	[in]	argType5 = MSyntax.MArgType
	[in]	argType6 = MSyntax.MArgType

Adds a flag to the list of flags accepted for the given command.
Also specifies any arguments required by the flag.'''
        pass

    def useSelectionAsDefault(self, useSelectionList): 
        '''useSelectionAsDefault(self, useSelectionList)
Arguments:
	[in]	useSelectionList = bool

Specifies that the command will use the current selection list
as arguments to the command if the command requires
 objects  and none are provided}.'''
        pass

    def enableEdit(self, supportsEdit): 
        '''enableEdit(self, supportsEdit)
Arguments:
	[in]	supportsEdit = bool

Sets whether or not the command supports the edit flag
("-e").'''
        pass

    def enableQuery(self, supportsQuery): 
        '''enableQuery(self, supportsQuery)
Arguments:
	[in]	supportsQuery = bool

Sets whether or not the command supports the query flag
("-q").'''
        pass

    def addArg(self, arg): 
        '''addArg(self, arg)
Arguments:
	[in]	arg = MSyntax.MArgType

Specifies the type of one of the arguments to the command. This
method can be called multiple times to specify multiple arguments
to the command.'''
        pass

    def makeFlagMultiUse(self, flag): 
        '''makeFlagMultiUse(self, flag)
Arguments:
	[in]	flag = char

Specifies that the given flag can be used by the command
multiple times in on the same command line.'''
        pass

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

Returns the lower limit on the number of objects accepted by the
command.'''
        pass

    def setMaxObjects(self, maximumObjectCount): 
        '''setMaxObjects(self, maximumObjectCount)
Arguments:
	[in]	maximumObjectCount = int

Specifies the upper limit on the number of objects accepted by
the command.'''
        pass

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

Returns the upper limit on the number of objects accepted by the
command.'''
        pass

    def setMinObjects(self, minimumObjectCount): 
        '''setMinObjects(self, minimumObjectCount)
Arguments:
	[in]	minimumObjectCount = int

Specifies the lower limit on the number of objects accepted by
the command.'''
        pass

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

    def index(self):
        '''This is an enum of MArgType.
Description: the index of the numerical input whose argument type is
requested
Value: None'''
        pass

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

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

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

    def kLastArgType(self):
        '''This is an enum of MArgType.
Description: 
Value: 11'''
        pass

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

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

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

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

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

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

    def kSelectionItem(self):
        '''This is an enum of MArgType.
Description: 
Value: 10'''
        pass

    class MArgType:
        '''Non-functional class.  Values for this enum:
        kLong
        index
        kString
        kDistance
        kInvalidArgType
        kLastArgType
        kAngle
        kUnsigned
        kBoolean
        kDouble
        kNoArg
        kTime
        kSelectionItem
'''
        def __init__(self):
            pass

    def setObjectType(self, objectFormat, minimumObjects, maximumObjects): 
        '''setObjectType(self, objectFormat, minimumObjects, maximumObjects)
Arguments:
	[in]	objectFormat = MSyntax.MObjectFormat
	[in]	minimumObjects = int
	[in]	maximumObjects = int

Specifies the representation of the objects passed to the
command as either MObjects or MStrings. Also specifies the upper
and lower limits of the number of objects accepted by the
command.'''
        pass

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

Returns whether or not the command supports the edit flag
("-e").'''
        pass

class MTesselationParams:
    '''Tesselation parameters. The subdivision criteria for refinement
of the initial mesh is specified as one of three formats; If the tesselation format is general then
you can choose which criteria you would like to use in the
tesselation. For each criterion, there is an "use" flag (in other
words, is this used?) together with the data for the criterion.'''
    def __init__(self):
        pass


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

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

    class PolyType:
        '''Non-functional class.  Values for this enum:
        kTriangles
        kQuads
'''
        def __init__(self):
            pass

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

Sets the minimum edge length. This value is used when the
subdivision criteria  kUseMinEdgeLength  has been set.'''
        pass

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

Sets the chord height ratio. This value is used when the
subdivision criteria  kUseChordHeightRatio  has been set.'''
        pass

    def setVIsoparmType(self, vValue): 
        '''setVIsoparmType(self, vValue)
Arguments:
	[in]	vValue = MTesselationParams.IsoparmType

Sets the v-isoparm type to be used in the initial
tesselation.'''
        pass

    def setUIsoparmType(self, uValue): 
        '''setUIsoparmType(self, uValue)
Arguments:
	[in]	uValue = MTesselationParams.IsoparmType

Sets the u-isoparm type to be used in the initial
tesselation.'''
        pass

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

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

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

    class TessFormat:
        '''Non-functional class.  Values for this enum:
        kGeneralFormat
        kTriangleCountFormat
        kStandardFitFormat
'''
        def __init__(self):
            pass

    def setEdgeSmoothFactor(self, smoothness): 
        '''setEdgeSmoothFactor(self, smoothness)
Arguments:
	[in]	smoothness = double

Sets the edge smoothness factor used for the Edge Smooth
secondary tesselation criteria.'''
        pass

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

Sets the diagonal distance of the bounding box of the
surface.'''
        pass

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

Sets the fraction of the 3D surface bounding box diagonal for
the kSurface3DDistance isoparm type. The value is 0.0 for other
types.'''
        pass

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

Sets the fractional tolerance which is used when the tesselation
format is  kStandardFitFormat .'''
        pass

    def setMaxUVRectangleSize(self, u, v): 
        '''setMaxUVRectangleSize(self, u, v)
Arguments:
	[in]	u = double
	[in]	v = double

Sets the maximum polygon size in uv-space for secondary
tesselation. Polygons will be greater than the specified size.'''
        pass

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

Sets the fraction of the 3D surface bounding box diagonal for
the kSurface3DDistance isoparm type. The value is 0.0 for other
types.'''
        pass

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

Sets the chord height ratio which is used when the tesselation
format is  kStandardFitFormat .'''
        pass

    def setOutputType(self, outputType): 
        '''setOutputType(self, outputType)
Arguments:
	[in]	outputType = MTesselationParams.PolyType

Specifies the type of polygons in the tesselated object.'''
        pass

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

Sets the minimum edge length which is used when the tesselation
format is  kStandardFitFormat .'''
        pass

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

This is the number of u isoparms used in the initial
tesselation. This value is only used for kSurface3DEquiSpaced,
kSurfaceEquiSpaced, and kSpanEquiSpaced isoparm types.'''
        pass

    def set3DDelta(self, delta): 
        '''set3DDelta(self, delta)
Arguments:
	[in]	delta = double

Sets the fraction of the box diagonal to be used as 3-d spacing
for u- and v-isoparams on face/surface to make up the initial grid
for the mesh. This is used when the tesselation format is
 kStandardFitFormat .'''
        pass

    def setMaxNumberPolys(self, value): 
        '''setMaxNumberPolys(self, value)
Arguments:
	[in]	value = int

Sets the maximum number of polygons. This value is used when the
subdivision criteria  kUseMaxNumberPolys  has been set.'''
        pass

    def setFormatType(self, format): 
        '''setFormatType(self, format)
Arguments:
	[in]	format = MTesselationParams.TessFormat

Sets the tesselation format. The tesselation format is used in
the secondary tesselation stage to specify the subdivision criteria
used in refining the initial mesh.'''
        pass

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

Sets the relative fit tolerance. This value is used when the
subdivision criteria  kUseRelativeTolerance  has been set.'''
        pass

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

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

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

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

    class IsoparmType:
        '''Non-functional class.  Values for this enum:
        kSurface3DDistance
        kSurfaceEquiSpaced
        kSpanEquiSpaced
        kSurface3DEquiSpaced
'''
        def __init__(self):
            pass

    def setSubdivisionFlag(self, subType, use): 
        '''setSubdivisionFlag(self, subType, use)
Arguments:
	[in]	subType = MTesselationParams.SubdivisionType
	[in]	use = bool

Sets the types of subdivision used when the tesselation format
is general. This method allows you to set the types of subdivision
to be performed after the initial mesh is created. The  use 
flag specifies whether to use the given subdivision type in the
secondary tesselation.'''
        pass

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

Sets the approximate number of triangles for the tesselated
object when the format is  kTriangleCountFormat .'''
        pass

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

Sets the maximum edge length. This value is used when the
subdivision criteria  kUseMaxEdgeLength  has been set.'''
        pass

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

This is the number of v isoparms used in the initial
tesselation. This value is only used for kSurface3DEquiSpaced,
kSurfaceEquiSpaced, and kSpanEquiSpaced isoparm types.'''
        pass

    def setWorldspaceToScreenTransform(self, value): 
        '''setWorldspaceToScreenTransform(self, value)
Arguments:
	[in]	value = MMatrix

The transformation matrix used in the minimum screen size test
for subdivision. This value is used when the subdivision criteria
 kUseMinScreenSize  has been set.'''
        pass

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

Sets the absolute fit tolerance. This value is used when the
subdivision criteria  kUseFractionalTolerance  has been
set.'''
        pass

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

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

    def kUseEdgeSmooth(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 10'''
        pass

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

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

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

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

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

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

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

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

    def kLastFlag(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 11'''
        pass

    class SubdivisionType:
        '''Non-functional class.  Values for this enum:
        kUseRelativeTolerance
        kUseMaxSubdivisionLevel
        kUseEdgeSmooth
        kUseMaxEdgeLength
        kUseTriangleEdgeSwapping
        kUseMaxUVRectangleSize
        kUseFractionalTolerance
        kUseMaxNumberPolys
        kUseChordHeightRatio
        kUseMinEdgeLength
        kUseMinScreenSize
        kLastFlag
'''
        def __init__(self):
            pass

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

Sets the maximum subdivision level. This value is used when the
subdivision criteria  kUseMaxSubdivisionLevel  has been
set.'''
        pass

    def setMinScreenSize(self, x, y): 
        '''setMinScreenSize(self, x, y)
Arguments:
	[in]	x = double
	[in]	y = double

If polygons are smaller than the specified screen size then the
subdivision will not proceed. These values are used when the
subdivision criteria  kUseMinScreenSize  has been set.'''
        pass

class MTime:
    '''Set and retrieve animation time values in various unit systems.'''
    def __init__(self):
        pass


    def setValue(self, newValue): 
        '''setValue(self, newValue)
Arguments:
	[in]	newValue = double

Set the current time value in the current units for this
instance.'''
        pass

    def uiUnit(self): 
        '''uiUnit(self) -> MTime.Unit

Returns the Working Units (or UI units) chosen in the settings
of the prefs window. Maya's timeslider displays  frames  in
these units.'''
        pass

    def __rmult__(self, rhs): 
        '''__rmult__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

In place multiplication by a scalar operator. Multiply the
current instance by the given double.'''
        pass

    def asUnits(self, newUnit): 
        '''asUnits(self, newUnit) -> double
Returns: Returns:
The current time value in the given units

Arguments:
	[in]	newUnit = MTime.Unit

Returns the current time value in the given units. This does not
affect the current units for the instance.'''
        pass

    def __div__(self, rhs): 
        '''__div__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

Division by a scalar operator. Divide the instance to the left
of the / operator by the given double, and assign the result to a
new  MTime 
instance.'''
        pass

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

Returns the current time value in the units that are currently
in effect for this instance.'''
        pass

    def __radd__(self, rhs): 
        '''__radd__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def as_func(self, newUnit): 
        '''as_func(self, newUnit) -> double
Returns: Returns:
The current time value in the given units

Arguments:
	[in]	newUnit = MTime.Unit

Returns the current time value in the given units. This does not
affect the current units for the instance.'''
        pass

    def __mul__(self, rhs): 
        '''__mul__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

Multiplication by a scalar operator. Multiply the instance to
the left of the * operator by the given double, and assign the
result to a new  MTime 
instance.'''
        pass

    def __rsub__(self, rhs): 
        '''__rsub__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def k120FPS(self):
        '''This is an enum of Unit.
Description: 120 frames per second
Value: 26'''
        pass

    def k100FPS(self):
        '''This is an enum of Unit.
Description: 100 frames per second
Value: 25'''
        pass

    def k750FPS(self):
        '''This is an enum of Unit.
Description: 750 frames per second
Value: 37'''
        pass

    def k4FPS(self):
        '''This is an enum of Unit.
Description: 4 frames per second
Value: 14'''
        pass

    def k250FPS(self):
        '''This is an enum of Unit.
Description: 250 frames per second
Value: 31'''
        pass

    def kUserDef(self):
        '''This is an enum of Unit.
Description: user defined units (not implemented yet)
Value: 43'''
        pass

    def k10FPS(self):
        '''This is an enum of Unit.
Description: 10 frames per second
Value: 18'''
        pass

    def k150FPS(self):
        '''This is an enum of Unit.
Description: 150 frames per second
Value: 28'''
        pass

    def kNTSCFrame(self):
        '''This is an enum of Unit.
Description: 30 frames per second
Value: 8'''
        pass

    def k400FPS(self):
        '''This is an enum of Unit.
Description: 400 frames per second
Value: 34'''
        pass

    def k75FPS(self):
        '''This is an enum of Unit.
Description: 75 frames per second
Value: 23'''
        pass

    def kFilm(self):
        '''This is an enum of Unit.
Description: 24 frames per second
Value: 6'''
        pass

    def k1500FPS(self):
        '''This is an enum of Unit.
Description: 1500 frames per second
Value: 39'''
        pass

    def k300FPS(self):
        '''This is an enum of Unit.
Description: 300 frames per second
Value: 32'''
        pass

    def k600FPS(self):
        '''This is an enum of Unit.
Description: 600 frames per second
Value: 36'''
        pass

    def k6000FPS(self):
        '''This is an enum of Unit.
Description: 6000 frames per second
Value: 42'''
        pass

    def k16FPS(self):
        '''This is an enum of Unit.
Description: 16 frames per second
Value: 20'''
        pass

    def kShowScan(self):
        '''This is an enum of Unit.
Description: twice the speed of film (48 frames per second)
Value: 9'''
        pass

    def kNTSCField(self):
        '''This is an enum of Unit.
Description: twice the speed of NTSC (60 frames per second)
Value: 11'''
        pass

    def k3FPS(self):
        '''This is an enum of Unit.
Description: 3 frames per second
Value: 13'''
        pass

    def k1200FPS(self):
        '''This is an enum of Unit.
Description: 1200 frames per second
Value: 38'''
        pass

    def k375FPS(self):
        '''This is an enum of Unit.
Description: 375 frames per second
Value: 33'''
        pass

    def k12FPS(self):
        '''This is an enum of Unit.
Description: 12 frames per second
Value: 19'''
        pass

    def k40FPS(self):
        '''This is an enum of Unit.
Description: 40 frames per second
Value: 22'''
        pass

    def kPALField(self):
        '''This is an enum of Unit.
Description: twice the speed of PAL (50 frames per second)
Value: 10'''
        pass

    def kMilliseconds(self):
        '''This is an enum of Unit.
Description: 1/1000 of a second
Value: 4'''
        pass

    def k5FPS(self):
        '''This is an enum of Unit.
Description: 5 frames per second
Value: 15'''
        pass

    def k500FPS(self):
        '''This is an enum of Unit.
Description: 500 frames per second
Value: 35'''
        pass

    def kLast(self):
        '''This is an enum of Unit.
Description: Last value, used for counting.
Value: 44'''
        pass

    def k8FPS(self):
        '''This is an enum of Unit.
Description: 8 frames per second
Value: 17'''
        pass

    def kGames(self):
        '''This is an enum of Unit.
Description: 15 frames per second
Value: 5'''
        pass

    def k20FPS(self):
        '''This is an enum of Unit.
Description: 20 frames per second
Value: 21'''
        pass

    def kInvalid(self):
        '''This is an enum of Unit.
Description: Invalid value.
Value: 0'''
        pass

    def kMinutes(self):
        '''This is an enum of Unit.
Description: 60 seconds
Value: 2'''
        pass

    def k80FPS(self):
        '''This is an enum of Unit.
Description: 80 frames per second
Value: 24'''
        pass

    def kHours(self):
        '''This is an enum of Unit.
Description: 3600 seconds
Value: 1'''
        pass

    def k3000FPS(self):
        '''This is an enum of Unit.
Description: 3000 frames per second
Value: 41'''
        pass

    def k2FPS(self):
        '''This is an enum of Unit.
Description: 2 frames per second
Value: 12'''
        pass

    def kSeconds(self):
        '''This is an enum of Unit.
Description: 1 second
Value: 3'''
        pass

    def k125FPS(self):
        '''This is an enum of Unit.
Description: 125 frames per second
Value: 27'''
        pass

    def k200FPS(self):
        '''This is an enum of Unit.
Description: 200 frames per second
Value: 29'''
        pass

    def kPALFrame(self):
        '''This is an enum of Unit.
Description: 25 frames per second
Value: 7'''
        pass

    def k6FPS(self):
        '''This is an enum of Unit.
Description: 6 frames per second
Value: 16'''
        pass

    def k2000FPS(self):
        '''This is an enum of Unit.
Description: 2000 frames per second
Value: 40'''
        pass

    def k240FPS(self):
        '''This is an enum of Unit.
Description: 240 frames per second
Value: 30'''
        pass

    class Unit:
        '''Non-functional class.  Values for this enum:
        k120FPS
        k100FPS
        k750FPS
        k4FPS
        k250FPS
        kUserDef
        k10FPS
        k150FPS
        kNTSCFrame
        k400FPS
        k75FPS
        kFilm
        k1500FPS
        k300FPS
        k600FPS
        k6000FPS
        k16FPS
        kShowScan
        kNTSCField
        k3FPS
        k1200FPS
        k375FPS
        k12FPS
        k40FPS
        kPALField
        kMilliseconds
        k5FPS
        k500FPS
        kLast
        k8FPS
        kGames
        k20FPS
        kInvalid
        kMinutes
        k80FPS
        kHours
        k3000FPS
        k2FPS
        kSeconds
        k125FPS
        k200FPS
        kPALFrame
        k6FPS
        k2000FPS
        k240FPS
'''
        def __init__(self):
            pass

    def __add__(self, rhs): 
        '''__add__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def __rdiv__(self, rhs): 
        '''__rdiv__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

In place division by a scalar operator. Divide the current
instance by the given double.'''
        pass

    def __sub__(self, rhs): 
        '''__sub__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTime

'''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTime

'''
        pass

    def setUnit(self, newUnit): 
        '''setUnit(self, newUnit)
Arguments:
	[in]	newUnit = MTime.Unit

Set the current units in effect on this  MTime 
instance. Note that this method only changes the current units in
the instance, it does not affect the value. So, calls to the value
method before and after a call to setUnit will return the same
number, however, the interpretation of that number will be
different due to the change in unit systems.'''
        pass

    def unit(self): 
        '''unit(self) -> MTime.Unit

Returns the current units in effect for this instance.'''
        pass

    def setUIUnit(self, newUnit): 
        '''setUIUnit(self, newUnit)
Arguments:
	[in]	newUnit = MTime.Unit

Set the unit system to be used by the user in the UI. After the
successful completion of this method, Maya's timeslider will be
displaying  frames  in the specified units.'''
        pass

class MTimer:
    '''This class works similar to timerX MEL command.'''
    def __init__(self):
        pass


    def clear(self): 
        '''clear(self)
'''
        pass

    def beginTimer(self): 
        '''beginTimer(self)
The call to this function starts the timer. 
  Reprocessed example '''
        pass

    def endTimer(self): 
        '''endTimer(self)
The call to this function ends the timer. 
  Reprocessed example '''
        pass

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

This function returns the time elapsed between the calls to
beginTimer and endTimer.   Reprocessed example '''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTimer

Equality operator. Checks whether the start time and end time
are same.'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTimer

InEquality operator.'''
        pass

class MTimerMessage:
    '''Register callbacks that are based on a fixed time interval.'''
    def __init__(self):
        pass


    def addTimerCallback(self, period, func, clientData): 
        '''addTimerCallback(self, period, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	period = float
	[in]	func = MMessage.MElapsedTimeFunction
	[in]	clientData = void

This method registers a callback which is called repeatedly with
a specified period of time between calls. Each time the timer fires
the callback will be placed on the idle queue for execution in the
next idle cycle. If the timer fires again, before the previous
invocation has completed execution, the new firing will be
skipped.'''
        pass

    def setSleepCallback(self, sleepFunc): 
        '''setSleepCallback(self, sleepFunc)
Arguments:
	[in]	sleepFunc = sleepCallbackPtr

This method is obsolete.'''
        pass

    def sleepCallback(self): 
        '''sleepCallback(self) -> MTimerMessage.sleepCallbackPtr

'''
        pass

class MTimeArray:
    '''Array of MTimedata type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MTime
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MTime
	[in]	index = int

Sets the value of the indicated element to the indicated
 MTime 
value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MTime
Returns: Returns:
A reference to the indicated element

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MTime

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MTransformationMatrix:
    '''Transformation matrix.Note that the default RotationOrder is kXYZ.'''
    def __init__(self):
        pass


    identity = ''
    '''The identity transformation
matrix.'''

    def addRotationQuaternion(self, x, y, z, w, space): 
        '''addRotationQuaternion(self, x, y, z, w, space)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double
	[in]	space = MSpace.Space

Add to the rotation component by rotating relative to the
existing transformation. Rotation is a quaternion. The only valid
transformation spaces for this method are  MSpace::kTransform 
and  MSpace::kPreTransform .
All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def scalePivot(self, space): 
        '''scalePivot(self, space) -> MPoint
Returns: Returns:
Scale pivot point

Arguments:
	[in]	space = MSpace.Space

Returns the pivot around which the scale is applied.'''
        pass

    def setScale(self, scale, space): 
        '''setScale(self, scale, space)
Arguments:
	[in]	scale = double3
	[in]	space = MSpace.Space

Set the scale component of the transformation matrix.'''
        pass

    def getTranslation(self, space): 
        '''getTranslation(self, space) -> MVector
Returns: Returns:
Translation vector in centimeters

Arguments:
	[in]	space = MSpace.Space

Returns the translation component of the translation as a vector
in centimeters.'''
        pass

    def getRotation(self, rot, order): 
        '''getRotation(self, rot, order)
Arguments:
	[out]	rot = double3
	[out]	order = MTransformationMatrix.RotationOrder

Get the rotation component of the transformation matrix in
radians. The rotation is retrieved in  MSpace::kTransform 
space.'''
        pass

    def rotateTo(self, e): 
        '''rotateTo(self, e) -> MTransformationMatrix
Returns: Returns:
A reference to the resulting transformation matrix

Arguments:
	[in]	e = MEulerRotation

Sets the rotation component of the transformation matrix using
an euler rotation. The rotation is performed in  MSpace::kTransform 
space.'''
        pass

    def getShear(self, space, shear): 
        '''getShear(self, space, shear)
Arguments:
	[out]	shear = double3
	[in]	space = MSpace.Space

Get the shear component of the transformation matrix.'''
        pass

    def addTranslation(self, vector, space): 
        '''addTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Add to the translation component by translating relative to the
existing transformation.'''
        pass

    def rotation(self): 
        '''rotation(self) -> MQuaternion

Returns the rotation component of the transformation matrix as a
quaternion. The rotation is returned in  MSpace::kTransform 
space.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:
True if not equal

Arguments:
	[in]	other = MTransformationMatrix

Inequality operator.'''
        pass

    def setScalePivot(self, point, space, balance): 
        '''setScalePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

Set the pivot around which the scale is applied.'''
        pass

    def reorderRotation(self, order): 
        '''reorderRotation(self, order)
Arguments:
	[in]	order = MTransformationMatrix.RotationOrder

Reorders the x, y, and z components of the rotation of this
transform. The overall rotation will remain the same. This
operation is not unique, so spin information will be lost.'''
        pass

    def asMatrixInverse(self): 
        '''asMatrixInverse(self) -> MMatrix

Returns the inverse of the four by four matrix that describes
this transformation.'''
        pass

    def rotatePivot(self, space): 
        '''rotatePivot(self, space) -> MPoint
Returns: Returns:
Rotation pivot point

Arguments:
	[in]	space = MSpace.Space

Returns the pivot around which the rotation is applied.'''
        pass

    def setRotatePivotTranslation(self, vector, space): 
        '''setRotatePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Set the pivot translation. This component is used to preserve
existing transformations when moving pivot. This method will only
be useful to advanced users.'''
        pass

    def addScale(self, scale, space): 
        '''addScale(self, scale, space)
Arguments:
	[in]	scale = double3
	[in]	space = MSpace.Space

Add to the scale component by scaling relative to the existing
transformation.'''
        pass

    def rotatePivotTranslation(self, space): 
        '''rotatePivotTranslation(self, space) -> MVector
Returns: Returns:
Scale pivot translation

Arguments:
	[in]	space = MSpace.Space

Returns the rotation pivot translation. This is the translation
that is used to compensate for the movement of the rotation
pivot.'''
        pass

    def setToRotationAxis(self, axis, rotation): 
        '''setToRotationAxis(self, axis, rotation)
Arguments:
	[in]	axis = MVector
	[in]	rotation = double

Sets the rotation given an axis and a rotation about it.'''
        pass

    def rotateBy(self, e, space): 
        '''rotateBy(self, e, space) -> MTransformationMatrix
Returns: Returns:
A reference to the resulting transformation matrix

Arguments:
	[in]	e = MEulerRotation
	[in]	space = MSpace.Space

Adds to the rotation component of the rotation matrix by
rotating relative to the existing transformation using an euler
rotation. The only valid transformation spaces for this method are
 MSpace::kTransform 
and  MSpace::kPreTransform /MSpacekObject.
All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def asScaleMatrix(self): 
        '''asScaleMatrix(self) -> MMatrix

Returns scale space matrix. The scale space matrix takes points
from object space to the space immediately following scale and
shear transformations.'''
        pass

    def setRotation(self, rot, order): 
        '''setRotation(self, rot, order)
Arguments:
	[in]	rot = double3
	[in]	order = MTransformationMatrix.RotationOrder

Set the rotation component of the transformation matrix. The
rotation is set in  MSpace::kTransform 
space.'''
        pass

    def asMatrix(self, percent): 
        '''asMatrix(self, percent) -> MMatrix
Returns: Returns:
The percentage matrix

Arguments:
	[in]	percent = double

Returns a matrix that represents the specified percentage of
this transformation matrix.'''
        pass

    def setTranslation(self, vector, space): 
        '''setTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Set the translation component of the transformation matrix in
centimeters.'''
        pass

    def getRotationQuaternion(self, x, y, z, w): 
        '''getRotationQuaternion(self, x, y, z, w)
Arguments:
	[out]	x = double
	[out]	y = double
	[out]	z = double
	[out]	w = double

Get the rotation component of the transformation matrix as a
quaternion. The rotation is retrieved in  MSpace::kTransform 
space.'''
        pass

    def rotationOrder(self): 
        '''rotationOrder(self) -> MTransformationMatrix.RotationOrder
Returns: Returns:
Rotation order

Returns the rotation order for the transform matrix. That is the
order in which the Euler angles are applied to create the end
rotation.'''
        pass

    def setRotatePivot(self, point, space, balance): 
        '''setRotatePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

Set the pivot around which the rotation is applied.'''
        pass

    def scalePivotTranslation(self, space): 
        '''scalePivotTranslation(self, space) -> MVector
Returns: Returns:
Scale pivot translation

Arguments:
	[in]	space = MSpace.Space

Returns the scale pivot translation. This is the translation
that is used to compensate for the movement of the scale pivot.'''
        pass

    def addRotation(self, rot, order, space): 
        '''addRotation(self, rot, order, space)
Arguments:
	[in]	rot = double3
	[in]	order = MTransformationMatrix.RotationOrder
	[in]	space = MSpace.Space

Add to the rotation component by rotating relative to the
existing transformation. The only valid transformation spaces for
this method are  MSpace::kTransform 
and  MSpace::kPreTransform .
All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def setRotationOrientation(self, q): 
        '''setRotationOrientation(self, q) -> MTransformationMatrix

Arguments:
	[in]	q = MQuaternion

Sets the rotation orientation for the transformation matrix. The
rotation orientation is the rotation that orients the local
rotation space. The rotation is set in  MSpace::kTransform 
space.'''
        pass

    def addShear(self, shear, space): 
        '''addShear(self, shear, space)
Arguments:
	[in]	shear = double3
	[in]	space = MSpace.Space

Add to the shear component by shearing relative to the existing
transformation.'''
        pass

    def getScale(self, space, scale): 
        '''getScale(self, space, scale)
Arguments:
	[out]	scale = double3
	[in]	space = MSpace.Space

Get the scale component of the transformation matrix.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
True if equal

Arguments:
	[in]	other = MTransformationMatrix

Equality operator.'''
        pass

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

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

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

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

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

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

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

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

    class RotationOrder:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kZXY
        kXYZ
        kYZX
        kYXZ
        kLast
        kXZY
        kZYX
'''
        def __init__(self):
            pass

    def asRotateMatrix(self): 
        '''asRotateMatrix(self) -> MMatrix

Returns rotate space matrix. The rotate space matrix takes
points from object space to the space immediately following the
scale/shear/rotation transformations.'''
        pass

    def rotationOrientation(self): 
        '''rotationOrientation(self) -> MQuaternion

Returns the rotation orientation for the transformation matrix.
The rotation orientation is the rotation that orients the local
rotation space. The rotation is returned in  MSpace::kTransform 
space.'''
        pass

    def eulerRotation(self): 
        '''eulerRotation(self) -> MEulerRotation

Returns the rotation component of the transformation matrix as
an euler rotation.'''
        pass

    def setShear(self, shear, space): 
        '''setShear(self, shear, space)
Arguments:
	[in]	shear = double3
	[in]	space = MSpace.Space

Set the shear component of the transformation matrix. The shear
values represent (xy, xz, yx).'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: Returns:
True if equivalent

Arguments:
	[in]	other = MTransformationMatrix
	[in]	tol = double

Returns true if this transform matrix is equivalent to the one
passed in within a certain tolerance.'''
        pass

    def setScalePivotTranslation(self, vector, space): 
        '''setScalePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space

Set the pivot translation. This component is used to preserve
existing scale transformations when moving pivot. This method will
only be useful to advanced users.'''
        pass

    def setRotationQuaternion(self, x, y, z, w): 
        '''setRotationQuaternion(self, x, y, z, w)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double

Set the rotation component of the transformation matrix using a
quaternion. The rotation is set in  MSpace::kTransform 
space.'''
        pass

class MTrimBoundaryArray:
    '''An array class for trim boundaries.'''
    def __init__(self):
        pass


    def insert(self, boundary, index): 
        '''insert(self, boundary, index)
Arguments:
	[in]	boundary = MObjectArray
	[in]	index = int

This method adds a new boundary into the "index" position.'''
        pass

    def set(self, boundary, index): 
        '''set(self, boundary, index)
Arguments:
	[in]	boundary = MObjectArray
	[in]	index = int

This method is used to replace an existing boundary array.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MObjectArray
Returns: Returns:
The MObjectArray requested

Arguments:
	[in]	index = int

The index operator. NOTE: no bounds are checked by this
method.'''
        pass

    def get(self, index): 
        '''get(self, index) -> const MObjectArray
Returns: Returns:
The MObjectArray requested

Arguments:
	[in]	index = int

The method returns the  MObjectArray  specified by the
index. NOTE: no bounds are checked by this method.'''
        pass

    def clear(self): 
        '''clear(self)
This method clears the trim boundary array.'''
        pass

    def getMergedBoundary(self, index): 
        '''getMergedBoundary(self, index) -> MObject
Returns: Returns:


MS::kSuccess if the curve
creation worked and MS::kFailure otherwise

Arguments:
	[in]	index = int

This function create a curve that represent all curves of the
boundary. The original boundary edges are not changed. Note that
the resulting curve is not added to the current model but is owned
by an  MObject  which is
of type kNurbsCurveData.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

This method removes an existing boundary from the list.'''
        pass

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

'''
        pass

    def reserve(self, reserveLength): 
        '''reserve(self, reserveLength)
Arguments:
	[in]	reserveLength = int

This method is used to reserve the capacity of the array.'''
        pass

    def append(self, boundary): 
        '''append(self, boundary)
Arguments:
	[in]	boundary = MObjectArray

Add a new boundary array at the end of the list.'''
        pass

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

'''
        pass

class MTypeId:
    '''Manage Maya Object type identifiers.'''
    def __init__(self):
        pass


    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool
Returns: Returns:
True of the two MTypeId hold the
same 32-bit binary tag.

Arguments:
	[in]	rhs = MTypeId

Equivalence operator.'''
        pass

    def id(self): 
        '''id(self) -> int
Returns: Returns:
The 32-bit id tag contained in this MTypeId instance.

Return the 32 bit id tag contained in the  MTypeId  instance'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool
Returns: Returns:
True of the two MTypeId hold
different 32-bit binary tags.

Arguments:
	[in]	rhs = MTypeId

Inequality operator.'''
        pass

class MUint64Array:
    '''Array of MUint64 data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MUint64
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MUint64
	[in]	index = int

Sets the value of the indicated element to the indicated MUint64
value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = MUint64

Copy the elements of the array into the given C++ array of
MUint64s. No checking is done to ensure that the destination C++
array of MUint64s is large enough to hold all the elements of the
instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MUint64Array

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MUint64

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MUintArray:
    '''Array of integers data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int

Sets the value of the indicated element to the indicated
value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = int

Copy the elements of the array into the given C++ array of
unsigned ints. No checking is done to ensure that the destination
C++ array of ints is large enough to hold all the elements of the
instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MUintArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = int

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MUserEventMessage:
    '''User defined Message Types.'''
    def __init__(self):
        pass


    def isUserEvent(self, eventName): 
        '''isUserEvent(self, eventName) -> bool
Returns: Returns:


true Event type exists
false Event type does not exist

Arguments:
	[in]	eventName = MString

Checks if an event type exists with the given event name.'''
        pass

    def postUserEvent(self, eventName, clientData): 
        '''postUserEvent(self, eventName, clientData)
Arguments:
	[in]	eventName = MString
	[in]	clientData = void

Notifies all callbacks attached to the given event type of the
occurence of the event.'''
        pass

    def deregisterUserEvent(self, eventName): 
        '''deregisterUserEvent(self, eventName)
Arguments:
	[in]	eventName = MString

Removes the event type with the given event name. If callbacks
have been registered with this event type, they will become invalid
after a successful call to this method.'''
        pass

    def addUserEventCallback(self, eventName, func, clientData): 
        '''addUserEventCallback(self, eventName, func, clientData) -> MCallbackId

Arguments:
	[in]	eventName = MString
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

This method registers a callback for user-defined messages.'''
        pass

    def registerUserEvent(self, eventName): 
        '''registerUserEvent(self, eventName)
Arguments:
	[in]	eventName = MString

Adds a new event type with the given string identifier. The
string identifier can then be used in all other  MUserEventMessage  methods to
operate on the new event type.'''
        pass

class MVector:
    '''A vector math class for vectors of doubles.'''
    def __init__(self):
        pass


    yAxis = ''
    '''Unit vector in the positive y
direction.'''

    yNegAxis = ''
    '''Unit vector in the negative z
direction.'''

    zNegAxis = ''
    '''Unit vector in the negative z
direction.'''

    one = ''
    '''The vector <1,1,1>.'''

    xNegAxis = ''
    '''Unit vector in the negative z
direction.'''

    zero = ''
    '''The null vector.'''

    zAxis = ''
    '''Unit vector in the positive z
direction.'''

    xAxis = ''
    '''Unit vector in the positive x
direction.'''

    def __radd__(self, other): 
        '''__radd__(self, other) -> MVector

Arguments:
	[in]	other = MVector

The in place vector addition operator.'''
        pass

    def __rsub__(self, other): 
        '''__rsub__(self, other) -> MVector

Arguments:
	[in]	other = MVector

The in place vector subtraction operator.'''
        pass

    def rotateTo(self, other): 
        '''rotateTo(self, other) -> MQuaternion
Returns: Returns:
The resulting quaternion.

Arguments:
	[out]	other = MVector

Returns the quaternion that represents the rotation of this
vector into the other vector about their mutually perpendicular
axis.'''
        pass

    def __rdiv__(self, scalar): 
        '''__rdiv__(self, scalar) -> MVector

Arguments:
	[in]	scalar = double

The in place division operator.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:
Bool false if the vectors are identical and true
otherwise.

Arguments:
	[in]	other = MVector

The vector inequality operator. This returns false if all three
of the x, y, and z components are identical.'''
        pass

    def normalize(self): 
        '''normalize(self)
Performs an in place normalization of the vector'''
        pass

    def angle(self, other): 
        '''angle(self, other) -> double
Returns: Returns:
The angle in radians

Arguments:
	[in]	other = MVector

Returns the angle in radians between the vector and the one
passed as an argument.'''
        pass

    def isParallel(self, other, tol): 
        '''isParallel(self, other, tol) -> bool
Returns: Returns:
true if the vectors are parallel and false otherwise

Arguments:
	[in]	other = MVector
	[in]	tol = double

Returns true if the current vector and the one passed as an
argument are parallel to each other within the specified
tolerance.'''
        pass

    def normal(self): 
        '''normal(self) -> MVector

'''
        pass

    def __div__(self, scalar): 
        '''__div__(self, scalar) -> MVector

Arguments:
	[in]	scalar = double

The division operator.'''
        pass

    def rotateBy(self, e): 
        '''rotateBy(self, e) -> MVector
Returns: Returns:
The resulting vector.

Arguments:
	[out]	e = MEulerRotation

Returns the vector that represents the rotation of this vector
by the given euler rotation.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double

Arguments:
	[in]	i = int

The index operator. If its argument is 0 it will return the x
component of the vector. If its argument is 1 it will return the y
component of the vector. Otherwise it will return the z component
of the vector.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = double3

Extracts the x, y, and z components of the vector and places
them in elements 0, 1, and 2 of the double array passed.'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: Returns:
Bool true if the vectors are equivalent and false
otherwise.

Arguments:
	[in]	other = MVector
	[in]	tol = double

Returns true if the vector and the one passed as an argument are
equal to each other within the specified tolerance.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MVector

Arguments:
	[in]	other = MVector

The vector addition operator.'''
        pass

    def transformAsNormal(self, matrix): 
        '''transformAsNormal(self, matrix) -> MVector
Returns: Returns:
The resulting transformed vector

Arguments:
	[in]	matrix = MMatrix

This method treats the vector as a normal vector and returns a
transformed copy of the vector.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Returns:
Bool true if the vectors are identical and false
otherwise.

Arguments:
	[in]	other = MVector

The vector equality operator. This returns true if all three of
the x, y, and z components are identical.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MVector

Arguments:
	[in]	right = MMatrix

'''
        pass

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

Return the length of the vector. 
  Reprocessed example '''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> MVector

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MVector

Arguments:
	[in]	other = MVector

The vector subtraction operator.'''
        pass

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

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

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

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

    class Axis:
        '''Non-functional class.  Values for this enum:
        kWaxis
        kXaxis
        kYaxis
        kZaxis
'''
        def __init__(self):
            pass

class MVectorArray:
    '''Array of MVectors data type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MVector
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = float3
	[in]	index = int

Sets the value of the indicated element to the indicated float
array value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MVector
Returns: Returns:
The value of the indicated element.

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = float

Copy the elements of the array into the given C++ array of float
arrays. No checking is done to ensure that the destination C++
array of floats arrays is large enough to hold all the elements of
the instance.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

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

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

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

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MVectorArray

Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int

Set the length of the array. This will grow and shrink the array
as desired. Elements that are grown have uninitialized values,
while those which are shrunk will lose the data contained in the
deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MVector

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MWeight:
    '''Component weight data.'''
    def __init__(self):
        pass


    def influence(self): 
        '''influence(self) -> float

Current influence weight.'''
        pass

    def seam(self): 
        '''seam(self) -> float

Current seam weight.'''
        pass

