Campbell Barton
417aeb935a
by Alberto Torres Ruiz (dithi) --- quoting the patch submission This patchs adds the properties IpoCurve.driverBone and IpoCurve.driverBone2 and modifies IpoCurve.driverChannel to allow OB_ROT_DIFF. It sets the driver type to pose if IpoCurve.driverBone is not empty or None. Otherwise the driver type is set to object. Attached is the patch (with python doc) and an example .blend. It also fixes the confusing description of IpoCurve.driver
246 lines
9.1 KiB
Python
246 lines
9.1 KiB
Python
# Blender.IpoCurve module and the IpoCurve PyType object
|
|
|
|
"""
|
|
The Blender.IpoCurve submodule
|
|
|
|
B{New}:
|
|
- IpoCurves supports the operator [], which accesses the value of
|
|
curves at a given time.
|
|
|
|
This module provides access to the IpoCurve data in Blender. An Ipo is
|
|
composed of several IpoCurves, and an IpoCurve are composed of several
|
|
BezTriples.
|
|
|
|
@warning: Ipo curves store euler rotations as degrees/10.0 so 180.0 would be 18.0
|
|
|
|
Example::
|
|
import Blender
|
|
ipo = Blender.Ipo.Get('ObIpo') # retrieves an Ipo object
|
|
ipo.name = 'ipo1' # change the Ipo's name
|
|
icu = ipo[Blender.Ipo.OB_LOCX] # request X Location Ipo curve object
|
|
if icu != None and len(icu.bezierPoints) > 0: # if curve exists and has BezTriple points
|
|
val = icu[2.5] # get the curve's value at time 2.5
|
|
|
|
@type ExtendTypes: readonly dictionary
|
|
@var ExtendTypes: The available IpoCurve extend types.
|
|
- CONST - curve is constant beyond first and last knots
|
|
- EXTRAP - curve maintains same slope beyond first and last knots
|
|
- CYCLIC - curve values repeat beyond first and last knots
|
|
- CYCLIC_EXTRAP - curve values repeat beyond first and last knots,
|
|
but while retaining continuity
|
|
|
|
@type InterpTypes: readonly dictionary
|
|
@var InterpTypes: The available IpoCurve interpolation types.
|
|
- CONST - curve remains constant from current BezTriple knot
|
|
- LINEAR - curve is linearly interpolated between adjacent knots
|
|
- BEZIER - curve is interpolated by a Bezier curve between adjacent knots
|
|
"""
|
|
|
|
class IpoCurve:
|
|
"""
|
|
The IpoCurve object
|
|
===================
|
|
This object gives access to generic data from all Ipo curves objects
|
|
in Blender.
|
|
|
|
Important Notes for Rotation Ipo Curves:\n
|
|
For the rotation Ipo curves, the y values for points are in units of 10
|
|
degrees. For example, 45.0 degrees is stored as 4.50 degrees. These are the
|
|
same numbers you see in the Transform Properties pop-up menu ( NKey ) in
|
|
the IPO Curve Editor window. Positive rotations are in a counter-clockwise
|
|
direction, following the standard convention.
|
|
|
|
@ivar driver: Status of the driver. 1= object or armature/bone driver, 2= python expression, 0= no driver
|
|
@type driver: int
|
|
@ivar driverObject: Object used to drive the Ipo curve.
|
|
@type driverObject: Blender Object or None
|
|
@ivar driverBone: Name of the armature bone used to drive the Ipo curve.
|
|
If empty or None, sets driver type to object, otherwise sets driver type to pose. [0 - 31 chars]
|
|
@type driverBone: string or None
|
|
@ivar driverBone2: Name of the second bone used to drive the Ipo curve.
|
|
Only to be used with ROT_DIFF channel. [0 - 31 chars]
|
|
@type driverBone2: string or None
|
|
@ivar driverExpression: Python expression used to drive the Ipo curve. [0 - 127 chars]
|
|
@type driverExpression: string
|
|
@ivar sel: The selection state of this curve.
|
|
@type sel: bool
|
|
@ivar driverChannel: Object channel used to drive the Ipo curve.
|
|
Use module constants: IpoCurve.LOC_X, IpoCurve.LOC_Y, IpoCurve.LOC_Z,
|
|
IpoCurve.ROT_X, IpoCurve.ROT_Y, IpoCurve.ROT_Z, IpoCurve.SIZE_X,
|
|
IpoCurve.SIZE_Y, IpoCurve.SIZE_Z, IpoCurve.ROT_DIFF (this last one is only for pose type drivers)
|
|
@type driverChannel: int
|
|
@ivar name: The IpoCurve data name.
|
|
@type name: string
|
|
@ivar bezierPoints: The list of the curve's bezier points.
|
|
@type bezierPoints: list of BezTriples.
|
|
@ivar interpolation: The curve's interpolation mode. See L{InterpTypes} for
|
|
values.
|
|
@type interpolation: int
|
|
@ivar extend: The curve's extend mode. See L{ExtendTypes} for values.
|
|
|
|
B{Note}: Cyclic Ipo curves never reach the end value. If the first and
|
|
last bezier points do not have the same y coordinate, the value of the
|
|
curve when it "cycles" is that of the first point. If a user wants to
|
|
get the value of the final curve point, read the final point from the
|
|
curve::
|
|
|
|
ipo = Blender.Object.Get('Cube').ipo
|
|
icu = ipo['LocX']
|
|
endtime,endvalue = icu.bezierPoints[-1].pt
|
|
@type extend: int
|
|
"""
|
|
|
|
def __getitem__ (time):
|
|
"""
|
|
Returns the value of the curve at a particular time.
|
|
@type time: float
|
|
@param time: time (Vertex X) on the curve
|
|
@rtype: float
|
|
@return: value (Vertex Y) corresponding to the given time
|
|
"""
|
|
|
|
def __setitem__ (time):
|
|
"""
|
|
Sets the value (Vertex Y) of the curve at a particular time.
|
|
@type time: float
|
|
@param time: time (Vertex X) on the curve
|
|
"""
|
|
|
|
def setExtrapolation(extendmode):
|
|
"""
|
|
Sets the extend mode of the curve (B{deprecated}). B{Note}: new scripts
|
|
should use the L{extend} attribute instead.
|
|
@type extendmode: string
|
|
@param extendmode: the extend mode of the curve.
|
|
Can be Constant, Extrapolation, Cyclic or Cyclic_extrapolation.
|
|
@rtype: None
|
|
@return: None
|
|
"""
|
|
|
|
def getExtrapolation():
|
|
"""
|
|
Gets the extend mode of the curve (B{deprecated}). B{Note}: new scripts
|
|
should use the L{extend} attribute instead.
|
|
@rtype: string
|
|
@return: the extend mode of the curve. Can be Constant, Extrapolation, Cyclic or Cyclic_extrapolation.
|
|
"""
|
|
|
|
def setInterpolation(interpolationtype):
|
|
"""
|
|
Sets the interpolation type of the curve (B{deprecated}). B{Note}:
|
|
new scripts should use the L{interpolation} attribute instead.
|
|
@type interpolationtype: string
|
|
@param interpolationtype: the interpolation type of the curve. Can be Constant, Bezier, or Linear.
|
|
@rtype: None
|
|
@return: None
|
|
"""
|
|
|
|
def getInterpolation():
|
|
"""
|
|
Gets the interpolation type of the curve (B{deprecated}). B{Note}:
|
|
new scripts should use the L{interpolation} attribute instead.
|
|
@rtype: string
|
|
@return: the interpolation type of the curve. Can be Constant, Bezier, or Linear.
|
|
"""
|
|
|
|
def append(point):
|
|
"""
|
|
Adds a Bezier point to a IpoCurve.
|
|
@type point: BezTriple or tuple of 2 floats
|
|
@param point: Can either be a BezTriple, or the x and y coordinates of
|
|
the Bezier knot point.
|
|
@rtype: None
|
|
@return: None
|
|
"""
|
|
|
|
def addBezier(coordlist):
|
|
"""
|
|
Adds a Bezier point to a curve B{deprecated}). B{Note}: new scripts
|
|
should use L{append} instead.
|
|
@type coordlist: tuple of (at least) 2 floats
|
|
@param coordlist: the x and y coordinates of the new Bezier point.
|
|
@rtype: None
|
|
@return: None
|
|
"""
|
|
|
|
def delBezier(index):
|
|
"""
|
|
Deletes a Bezier point from a curve.
|
|
@type index: integer
|
|
@param index: the index of the Bezier point. Negative values index from the end of the list.
|
|
@rtype: None
|
|
@return: None
|
|
"""
|
|
|
|
def recalc():
|
|
"""
|
|
Recomputes the curve after changes to control points.
|
|
@rtype: None
|
|
@return: None
|
|
"""
|
|
|
|
def getName():
|
|
"""
|
|
Returns the name of the Ipo curve (B{deprecated}). B{Note}:
|
|
new scripts should use the L{name} attribute instead.
|
|
The name can be:
|
|
1. Camera Ipo: Lens, ClSta, ClEnd, Apert, FDist.
|
|
2. Material Ipo: R, G, B, SpecR, SpecG, SpecB, MirR, MirG, MirB, Ref,
|
|
Alpha, Emit, Amb, Spec, Hard, SpTra, Ior, Mode, HaSize, Translu,
|
|
RayMir, FresMir, FresMirI, FresTra, FresTraI, TraGlow, OfsX, OfsY,
|
|
OfsZ, SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var,
|
|
Disp.
|
|
3. Object Ipo: LocX, LocY, LocZ, dLocX, dLocY, dLocZ, RotX, RotY, RotZ,
|
|
dRotX, dRotY, dRotZ, SizeX, SizeY, SizeZ, dSizeX, dSizeY, dSizeZ,
|
|
Layer, Time, ColR, ColG, ColB, ColA, FStreng, FFall, Damping,
|
|
RDamp, Perm.
|
|
4. Lamp Ipo: Energ, R, G, B, Dist, SpoSi, SpoBl, Quad1, Quad2, HaInt.
|
|
5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
|
|
MisSta, MisHi, StaR, StaG, StaB, StarDi, StarSi, OfsX, OfsY, OfsZ,
|
|
SizeX, SizeY, SizeZ, TexR, TexG, TexB, DefVar, Col, Nor, Var.
|
|
5. World Ipo: HorR, HorG, HorB, ZenR, ZenG, ZenB, Expos, Misi, MisDi,
|
|
MisSta, MisHi, StarR, StarB, StarG, StarDi, StarSi, OfsX, OfsY, OfsZ,i
|
|
SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var.
|
|
6. Texture Ipo: NSize, NDepth, NType, Turb, Vnw1, Vnw2, Vnw3, Vnw4,
|
|
MinkMExp, DistM, ColT, iScale, DistA, MgType, MgH, Lacu, Oct,
|
|
MgOff, MgGain, NBase1, NBase2.
|
|
7. Curve Ipo: Speed.
|
|
8. Action Ipo: LocX, LocY, LocZ, SizeX, SizeY, SizeZ, QuatX, QuatY,
|
|
QuatZ, QuatW.
|
|
9. Sequence Ipo: Fac.
|
|
10. Constraint Ipo: Inf.
|
|
|
|
@rtype: string
|
|
@return: the name of the Ipo curve.
|
|
"""
|
|
|
|
def getPoints():
|
|
"""
|
|
Returns all the points of the IpoCurve (B{deprecated}).
|
|
B{Note}: new scripts should use the L{bezierPoints} attribute instead.
|
|
@rtype: list of BezTriples
|
|
@return: the points of the Ipo curve.
|
|
"""
|
|
|
|
def clean( thresh=0.0000001 ):
|
|
"""
|
|
Calls the IPO-curve cleaning function on this IpoCurve.
|
|
There is no need to recalculate curve manually.
|
|
@type thresh: float
|
|
@param thresh: The threshold to used to determine if two values are identical.
|
|
By default, the IPO-editor tool's value is used.
|
|
@rtype: None
|
|
@return: None
|
|
"""
|
|
|
|
def evaluate( time ):
|
|
"""
|
|
Compute the value of the Ipo curve at a particular time (B{deprecated}).
|
|
B{Note}: new scripts should use L{icu[time]<__getitem__>} instead.
|
|
@type time: float
|
|
@param time: value along the X axis
|
|
@rtype: float
|
|
@return: the Y value of the curve at the given time
|
|
"""
|
|
|