Go to:
				Related nodes. Attributes. 
This node implements an aimConstraint.  Each constraint has a set
        of targets that are connected under the target attribute, a single
        constrained object that is connected to the constraint* attributes,
        and possibly other information to help compute the correct results.
        In the case of the aimConstraint, the additional information is:
        aimVector, upVector, worldUpVector, worldUpMatrix, and
        worldUpType.
        The aimConstraint node can have any number of target inputs.
        Each target is connected to attributes inside a single element
        of the target attribute.  For example, the first target object
        would be connected elements of target[0], the second target object
        would be connected to elements of target[1], etc.  The elements of
        each target are: targetTranslate, targetRotatePivot,
        targetRotateTranslate, targetParentMatrix, and targetWeight.
        The elements of each target are normally connected to the target
        objects as follows:
        
                
                        
                                | aimConstraint attribute | 
                                connected to | 
                        
                        
                                | targetTranslate | 
                                translate | 
                        
                        
                                | targetRotatePivot | 
                                rotatePivot | 
                        
                        
                                | targetRotateTranslate | 
                                rotatePivotTranslate | 
                        
                        
                                | targetParentMatrix | 
                                parentMatrix[i] | 
                        
                        
                                | targetWeight | 
                                set to 1.0 | 
                        
                
        
        The targetWeight attribute is not generally connected to the
        target object.  Instead, it may be animated by other means to
        adjust the weighted average computation for the target point.
        The aimConstraint node uses these inputs to compute the world
        space position of the pivot point of each target object.  It then
        computes a weighted average of the these pivot points.  This
        weighted average is called the target point.
        The constrained object is connected to the constraint*
        attributes.  For an aimConstraint, the constraintTranslate,
        constraintRotatePivot, constraintRotateTranslate,
        constraintJointOrient, and constraintParentInverseMatrix are
        inputs to the aimConstraint.  The attributes constraintRotate and
        constraintVector are outputs.
        The additional aimConstraint inputs tell the constraint node
        how to orient the constrained object.  The aimVector attribute
        defines a vector in the space of the constrained object that
        should be oriented along the line from the pivot point of the
        constrained object to the target point.  The upVector,
        worldUpVector, worldUpMatrix, and worldUpType define how the
        constrained object is rotated about the aimVector.
        The upVector defines a vector in the space of the constrained
        object, very much like the aimVector does.  The constrained object is
        rotated so that the aimVector points at the target point and so that
        the upVector aligns as closely as possible with the computed world up
        vector.  The world up vector is determined by the worldUpType,
        worldUpVector, and worldUpMatrix attributes.
        The attribute worldUpType can have one of 5 values, which affects the
        calculation of the world up vector as shown in the following table.
        
                
                        
                                | Mnemonic | 
                                Value | 
                                Description | 
                        
                        
                                | scene | 
                                0 | 
                                
                                        The upVector is aligned with the up axis of the scene and
                                        worldUpVector and worldUpObject are ignored.
                                 | 
                        
                        
                                | object | 
                                1 | 
                                
                                        The upVector is aimed as closely as possible to the
                                        origin of the space of the worldUpObject and
                                        the worldUpVector is ignored.
                                 | 
                        
                        
                                | objectrotation | 
                                2 | 
                                
                                        The worldUpVector is interpreted as being in
                                        the coordinate space of the worldUpObject, transformed
                                        into world space and the upVector is aligned as
                                        closely as possible to the result.
                                 | 
                        
                        
                                | vector | 
                                3 | 
                                
                                        Default:
                                        The upVector is aligned with worldUpVector as closely as
                                        possible and worldUpMatrix is ignored.
                                 | 
                        
                        
                                | none | 
                                4 | 
                                
                                        No up vector is used in the computation of the orientation of the
                                        constrained object; only the aim vector and the target's position
                                        are used. Specifying an up vector can cause flipping to occur if the
                  constrained object's new orientation vector is close to the up vector.
                                        If the worldUpType is instead set to none, this flipping won't happen,
                                        at a loss of control over twisting.
                                 | 
                        
                
        
        While setAttr requires the numeric values for the worldUpType
        attribute, both numeric and mnemonic values are allowed by the
        aimConstraint command.
        Although the all the constraint nodes inherit from transform,
        they do not actively use any of the attributes from transform.
| Node name | Parents | Classification | MFn type | Compatible function sets | 
|---|
| aimConstraint | constraint | animation:drawdb/geometry/transform | kAimConstraint | kBase kNamedObject kDependencyNode kDagNode kTransform kConstraint kAimConstraint | 
Related nodes
geometryConstraint, normalConstraint, orientConstraint, parentConstraint, pointConstraint, poleVectorConstraint, tangentConstraint, scaleConstraint, lookAt
Attributes (69)
The following quick index only shows top-level attributes (too many attributes to show them all): aimVector (3), constraintJointOrient (3), constraintParentInverseMatrix, constraintRotate (3), constraintRotateOrder, constraintRotatePivot (3), constraintRotateTranslate (3), constraintTranslate (3), constraintVector (3), inverseScale (3), offset (3), restRotate (3), scaleCompensate, target (14), upVector (3), useOldOffsetCalculation, worldUpMatrix, worldUpType, worldUpVector (3)
| Long name (short name) | Type | Default | Flags | 
|---|
 | 
target 
				(tg)
				 | compound | n/a |       | 
|
 |  targetTranslate 
				(tt)
				 | double3 |  |      |  |
  |  targetTranslateX 
				(ttx)
				 | distance (double) | 0.0cm |      |  |
 
  |   |  targetTranslateY 
				(tty)
				 | distance (double) | 0.0cm |      |  |
 
  |   |  targetTranslateZ 
				(ttz)
				 | distance (double) | 0.0cm |      |  |
 
  |  
  | 
 |  targetRotatePivot 
				(trp)
				 | double3 |  |      |  |
  |  targetRotatePivotX 
				(trpx)
				 | distance (double) | 0.0cm |      |  |
 
  |   |  targetRotatePivotY 
				(trpy)
				 | distance (double) | 0.0cm |      |  |
 
  |   |  targetRotatePivotZ 
				(trpz)
				 | distance (double) | 0.0cm |      |  |
 
  |  
  | 
 |  targetRotateTranslate 
				(trt)
				 | double3 |  |      |  |
  |  targetRotateTranslateX 
				(trtx)
				 | distance (double) | 0.0cm |      |  |
 
  |   |  targetRotateTranslateY 
				(trty)
				 | distance (double) | 0.0cm |      |  |
 
  |   |  targetRotateTranslateZ 
				(trtz)
				 | distance (double) | 0.0cm |      |  |
 
  |  
  | 
 |  targetParentMatrix 
				(tpm)
				 | matrix | identity |      |  |
 
  | 
 |  targetWeight 
				(tw)
				 | double | 1.0 |      |  |
 
  | 
 | 
constraintParentInverseMatrix 
				(cpim)
				 | matrix | identity |      | 
|
 | 
aimVector 
				(a)
				 | double3 | 1.0,0.0,0.0 |      | 
|
 |  aimVectorX 
				(ax)
				 | double | 1.0 |      |  |
 
  | 
 |  aimVectorY 
				(ay)
				 | double | 0.0 |      |  |
 
  | 
 |  aimVectorZ 
				(az)
				 | double | 0.0 |      |  |
 
  | 
 | 
upVector 
				(u)
				 | double3 | 0.0,1.0,0.0 |      | 
|
 | 
 | 
 | 
 | 
worldUpVector 
				(wu)
				 | double3 | 0.0,1.0,0.0 |      | 
|
 |  worldUpVectorX 
				(wux)
				 | double | 0.0 |      |  |
 
  | 
 |  worldUpVectorY 
				(wuy)
				 | double | 1.0 |      |  |
 
  | 
 |  worldUpVectorZ 
				(wuz)
				 | double | 0.0 |      |  |
 
  | 
 | 
worldUpMatrix 
				(wum)
				 | matrix | identity |      | 
|
 | 
worldUpType 
				(wut)
				 | enum | 3 vector |      | 
|
 | 
constraintTranslate 
				(ct)
				 | double3 |  |      | 
|
 |  constraintTranslateX 
				(ctx)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 |  constraintTranslateY 
				(cty)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 |  constraintTranslateZ 
				(ctz)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 | 
constraintRotatePivot 
				(crp)
				 | double3 |  |      | 
|
 |  constraintRotatePivotX 
				(crpx)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 |  constraintRotatePivotY 
				(crpy)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 |  constraintRotatePivotZ 
				(crpz)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 | 
constraintRotateTranslate 
				(crt)
				 | double3 |  |      | 
|
 |  constraintRotateTranslateX 
				(crtx)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 |  constraintRotateTranslateY 
				(crty)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 |  constraintRotateTranslateZ 
				(crtz)
				 | distance (double) | 0.0cm |      |  |
 
  | 
 | 
constraintRotateOrder 
				(cro)
				 | enum | 0 |      | 
|
 | 
constraintJointOrient 
				(cjo)
				 | double3 |  |      | 
|
 |  constraintJointOrientX 
				(cjox)
				 | angle (double) | 0.0deg |      |  |
 
  | 
 |  constraintJointOrientY 
				(cjoy)
				 | angle (double) | 0.0deg |      |  |
 
  | 
 |  constraintJointOrientZ 
				(cjoz)
				 | angle (double) | 0.0deg |      |  |
 
  | 
 | 
scaleCompensate 
				(ssc)
				 | bool | true |      | 
|
 | 
inverseScale 
				(is)
				 | double3 |  |      | 
|
 |  inverseScaleX 
				(isx)
				 | double | 1.0 |      |  |
 
  | 
 |  inverseScaleY 
				(isy)
				 | double | 1.0 |      |  |
 
  | 
 |  inverseScaleZ 
				(isz)
				 | double | 1.0 |      |  |
 
  | 
 | 
constraintRotate 
				(cr)
				 | double3 |  |    | 
|
 |  constraintRotateX 
				(crx)
				 | angle (double) | 0.0deg |    |  |
 
  | 
 |  constraintRotateY 
				(cry)
				 | angle (double) | 0.0deg |    |  |
 
  | 
 |  constraintRotateZ 
				(crz)
				 | angle (double) | 0.0deg |    |  |
 
  | 
 | 
constraintVector 
				(cv)
				 | double3 |  |    | 
|
 |  constraintVectorX 
				(cvx)
				 | distance (double) | 0.0cm |    |  |
 
  | 
 |  constraintVectorY 
				(cvy)
				 | distance (double) | 0.0cm |    |  |
 
  | 
 |  constraintVectorZ 
				(cvz)
				 | distance (double) | 0.0cm |    |  |
 
  | 
 | 
offset 
				(o)
				 | double3 |  |      | 
|
 |  offsetX 
				(ox)
				 | angle (double) | 0.0deg |       |  |
 
  | 
 |  offsetY 
				(oy)
				 | angle (double) | 0.0deg |       |  |
 
  | 
 |  offsetZ 
				(oz)
				 | angle (double) | 0.0deg |       |  |
 
  | 
 | 
restRotate 
				(rsrr)
				 | double3 |  |      | 
|
 |  restRotateX 
				(rrx)
				 | angle (double) | 0.0deg |      |  |
 
  | 
 |  restRotateY 
				(rry)
				 | angle (double) | 0.0deg |      |  |
 
  | 
 |  restRotateZ 
				(rrz)
				 | angle (double) | 0.0deg |      |  |
 
  | 
 | 
useOldOffsetCalculation 
				(uooc)
				 | bool | false |      | 
|