Logo Search packages:      
Sourcecode: blender version File versions

Bone.py

# Blender.Armature.Bone module and the Bone PyType object

"""
The Blender.Armature.Bone submodule.

Bone
====

This module provides access to B{Bone} objects in Blender.  Bones are used to 
create armatures.

Example::
  import Blender
  from Blender import *
  from Blender.Armature import *
  from Blender.Armature.Bone import *

  armObj = Object.New('Armature', "Armature_obj")
  armData = Armature.New()

  bn1=Blender.Armature.Bone.New("bone1")
  bn1.setHead(0.0,0.0,0.0)
  bn1.setTail(2.0,1.0,0.0)

  bn2=Blender.Armature.Bone.New("bone2")
  bn2.setHead(3.0,2.0,1.0)
  bn2.setTail(4.0,4.0,1.0)
  bn2.setRoll(.5)
  bn2.setParent(bn1)

  bn3=Blender.Armature.Bone.New("bone3")
  bn3.setHead(5.0,6.0,2.0)
  bn3.setTail(5.0,8.0,2.0)
  bn3.setParent(bn2)

  armData.addBone(bn1)
  armData.addBone(bn2)
  armData.addBone(bn3)

  armData.drawAxes(1)
  armObj.link(armData)

  scn = Blender.Scene.getCurrent()
  scn.link(armObj)

  armObj.makeDisplayList()
  Blender.Window.RedrawAll()

  bn2.setPose([ROT,LOC,SIZE])  
  
@var PoseFlags: The available flags for setting keyframed poses.
    - ROT - add bone's rotation to keyframe
    - LOC - add bone's location to keyframe
    - SIZE- add bone's size to keyframe
    
@var BoneclassFlags: The available flags for setting boneclass.
    - SKINNABLE
    - UNSKINNABLE
    - HEAD
    - NECK
    - BACK
    - SHOULDER
    - ARM
    - HAND
    - FINGER
    - THUMB
    - PELVIS
    - LEG
    - FOOT
    - TOE
    - TENTACLE
"""

00074 class Bone:
  """
  The Bone object
  ===============
    This object gives access to Bone-specific data in Blender.
  @cvar name: The name of this Bone.
  @cvar roll: This Bone's roll value.
  @cvar head: This Bone's "head" ending position when in rest state.
  @cvar tail: This Bone's "tail" ending position when in rest state.
  @cvar loc: This Bone's location.
  @cvar size: This Bone's size.
  @cvar quat: This Bone's quaternion.
  @cvar parent: The parent Bone.
  @cvar children: The children bones.
  @cvar weight: The bone's weight.
  @cvar ik: Whether the bone is set to IK.
  @cvar boneclass: The boneclass of this bone.
  """

00093   def getName():
    """
    Get the name of this Bone.
    @rtype: string
    """

00099   def getRoll():
    """
    Get the roll value.
    @rtype: float
    @warn: Roll values are local to parent's objectspace when
    bones are parented.
    """

00107   def getWeight():
    """
    Get the bone's weight..
    @rtype: float
    """
    
00113   def getHead():
    """
    Get the "head" ending position.
    @rtype: list of three floats
    """

00119   def getTail():
    """
    Get the "tail" ending position.
    @rtype: list of three floats
    """

00125   def getLoc():
    """
    Get the location of this Bone.
    @rtype: list of three floats
    """

00131   def getSize():
    """
    Get the size attribute.
    @rtype: list of three floats
    """

00137   def getQuat():
    """
    Get this Bone's quaternion.
    @rtype: Quaternion object.
    """

00143   def hasParent():
    """
    True if this Bone has a parent Bone.
    @rtype: true or false
    """

00149   def getParent():
    """
    Get this Bone's parent Bone, if available.
    @rtype: Blender Bone
    """

00155   def getWeight():
    """
    Get the bone's weight.
    @rtype: float
    """

00161   def getChildren():
    """
    Get this Bone's children Bones, if available.
    @rtype: list of Blender Bones
    """

00167   def setName(name):
    """
    Rename this Bone.
    @type name: string
    @param name: The new name.
    """

00174   def setRoll(roll):
    """
    Set the roll value.
    @type roll: float
    @param roll: The new value.
    @warn: Roll values are local to parent's objectspace when
    bones are parented.
    """

00183   def setHead(x,y,z):
    """
    Set the "head" ending position.
    @type x: float
    @type y: float
    @type z: float
    @param x: The new x value.
    @param y: The new y value.
    @param z: The new z value.
    """

00194   def setTail(x,y,z):
    """
    Set the "tail" ending position.
    @type x: float
    @type y: float
    @type z: float
    @param x: The new x value.
    @param y: The new y value.
    @param z: The new z value.
    """

00205   def setLoc(x,y,z):
    """
    Set the new location for this Bone.
    @type x: float
    @type y: float
    @type z: float
    @param x: The new x value.
    @param y: The new y value.
    @param z: The new z value.
    """

00216   def setSize(x,y,z):
    """
    Set the new size for this Bone.
    @type x: float
    @type y: float
    @type z: float
    @param x: The new x value.
    @param y: The new y value.
    @param z: The new z value.
    """

00227   def setQuat(quat):
    """
    Set the new quaternion for this Bone.
    @type quat: Quaternion object or PyList of floats
    @param quat: Can be a Quaternion or PyList of 4 floats.
    """

00234   def setParent(bone):
    """
    Set the bones's parent in the armature.
    @type bone: PyBone
    @param bone: The Python bone that is the parent to this bone.
    """

00241   def setWeight(weight):
    """
    Set the bones's weight.
    @type weight: float
    @param weight: set the the bone's weight.
    """
    
00248   def hide():
    """
    Hides this bone.
    """
    
00253   def unhide():
    """
    Unhide this bone.
    """
    
00258   def clearParent():
    """
    Attempts to clear the parenting of this bone. Because the bone is no longer
    parented it will be set in the armature as a root bone.
    """
    
00264   def clearChildren():
    """
    Attemps to remove all the children of this bone. Because each of the
    children no longer are parented they will be set a root bones in the
    armature.
    """

00271   def setPose(flags, Action):
    """
    Set the pose for this bone. The pose will be set at the Scene's current
    frame. If an action is passed as the optional second parameter the pose
    will be added as a keyframe to that action. Otherwise a default action
    will be created an the pose set to it.
    @type flags: PyList of enums
    @param flags: expects ROT, LOC, SIZE in a list. Whichever of these is
        passed the keyframe generated will set information about the rotation,
        and/or location, and/or size of the bone.
    @type Action: PyAction
    @param Action: a python action that has either been created or returned
        from an object
    """

00286   def setBoneclass(boneclass):
    """
    Set the bones's boneclass.
    @type boneclass: Enumeration constant. See above.
    @param boneclass: The boneclass of this bone.
    """

00293   def getBoneclass():
    """
    Get this Bone's boneclass.
    @rtype: Enumeration const (string)
    """

00299   def hasIK():
    """
    Determines whether or not this bone as flaged as IK.
    @rtype: true (1) or false (0)
    """

00305   def getRestMatrix(locale = 'worldspace'):
    """
    Return a matrix that represents the rotation and position of this bone.
    There are two types of matrices that can be returned:
      1. bonespace (in the coord. system of parent) or
      2. worldspace (in the coord system of blender).

    The rotation will be in either worldspace or bonespace. Translation vectors
    (row 4) will be the bone's head position (if worldspace) or the difference
    from this bone's head to the parent head (if bonespace).
    @type locale: string. Values are:
    @param locale: possible values are:
      - worldspace (default)
      - bonespace
    @rtype: 4x4 PyMatrix
    """

Generated by  Doxygen 1.6.0   Back to index