archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

===Python API===

Browse Source 
New Ipo and IpoCurve API.  Ipo and IpoCurve objects support the [] operator,
for accessing the curves of a particular Ipo and for accessing the value
of an IpoCurve at a specific time.  Both modules were also "tp_getset"-ified.
Also, code for an alternative method (Antont wanted this) of accessing curves
via Ipo attributes is included for now, for people to try and see if it's
actually preferable to the Ipo [] operator.

These are all new additions; nothing was intentionally removed from the API.
If you find the something in the existing API has changed, let me know.
This commit is contained in:
Ken Hughes
2006-04-21 20:27:52 +00:00
parent 63868046f4
commit 4aa28f13f4
8 changed files with 2402 additions and 1321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2014
source/blender/python/api2_2x/Ipo.c
View File

File diff suppressed because it is too large Load Diff

2
source/blender/python/api2_2x/Ipo.h
View File

@@ -42,6 +42,8 @@
typedef struct {
PyObject_HEAD /* required macro */
Ipo * ipo;
short iter;
short mtex;
} BPy_Ipo;
extern PyTypeObject Ipo_Type;

919
source/blender/python/api2_2x/Ipocurve.c
View File

File diff suppressed because it is too large Load Diff

1
source/blender/python/api2_2x/Ipocurve.h
View File

@@ -42,6 +42,7 @@
typedef struct {
PyObject_HEAD /* required macro */
IpoCurve * ipocurve;
char wrapped;
} C_IpoCurve;
extern PyTypeObject IpoCurve_Type;

2
source/blender/python/api2_2x/doc/API_intro.py
View File

@@ -15,6 +15,7 @@ The Blender Python API Reference
-----------
- L{Armature}
- L{NLA}
- L{BezTriple}
- L{BGL}
- L{Camera}
- L{Curve}
@@ -23,6 +24,7 @@ The Blender Python API Reference
- L{Group} (*)
- L{Image}
- L{Ipo}
- L{IpoCurve}
- L{Key} (*)
- L{Lamp}
- L{Lattice}

94
source/blender/python/api2_2x/doc/BezTriple.py Normal file
View File

@@ -0,0 +1,94 @@
# Blender.BezTriple module and the BezTriple PyType object
"""
The Blender.BezTriple submodule
B{New}:
- new attributes L{handleTypes<BezTriple.handleTypes>},
L{selects<BezTriple.selects>} and L{weight<BezTriple.weight>}
This module provides access to the BezTriple Data in Blender. It is used by
CurNurb and IpoCurve objects.
@type HandleTypes: readonly dictionary
@var HandleTypes: The available BezTriple handle types.
- FREE - handle has no constrints
- AUTO - completely constrain handle based on knot position
- VECT - constraint handle to line between current and neighboring knot
- ALIGN - constrain handle to lie in a straight line with knot's other
handle
- AUTOANIM - constrain IPO handles to be horizontal on extremes
"""
def New (coords):
"""
Create a new BezTriple object.
@type coords: sequence of three or nine floats
@param coords: the coordinate values for the new control point. If three
floats are given, then the handle values are automatically generated.
@rtype: BezTriple
@return: a new BezTriple object
"""
class BezTriple:
"""
The BezTriple object
====================
This object gives access to generic data from all BezTriple objects in
Blender.
@ivar pt : the [x,y] coordinates for knot point of this BezTriple. After
changing coordinates of a Ipo curve, it is advisable to call
L{IpoCurve.recalc()<IpoCurve.IpoCurve.recalc>} to update the curve.
@type pt: list of two floats
@ivar vec : a list of the 3 points [ handle, knot, handle ] that comprise a
BezTriple, with each point composed of a list [x,y,z] of floats. The list
looks like [ [H1x, H1y, H1z], [Px, Py, Pz], [H2x, H2y, H2z] ].
Example::
# where bt is of type BezTriple
# and h1, p, and h2 are lists of 3 floats
h1, p, h2 = bt.vec
@type vec: list of points
@ivar tilt: the tilt/alpha value for the point
@type tilt: float
@ivar hide: the visibility status of the knot. B{Note}: true/nonzero means
I{not} hidden. B{Note}: primarily intended for curves; not a good idea to
hide IPO control points.
@type hide: int
@ivar handleTypes: the types of the point's two handles. See
L{HandleTypes} for a complete description.
@type handleTypes list of two ints
@ivar selects: the select status for [handle, knot, handle]. True/nonzero
if the point is selected.
@type selects: list of three ints
@ivar weight: the weight assigned to the control point. Useful for
softbodies and possibly others.
@type weight: float
"""
def getPoints():
"""
Returns the x,y coordinates of the Bezier knot point (B{deprecated}).
See the L{BezTriple.pt} attribute.
@rtype: list of floats
@return: list of the x and y coordinates of the Bezier point.
"""
def setPoints(newval):
"""
Sets the x,y coordinates of the Bezier knot point (B{deprecated}).
See the L{BezTriple.pt} attribute.
@type newval: tuple of 2 floats
@param newval: the x and y coordinates of the new Bezier point.
@rtype: None
@return: None
"""
def getTriple():
"""
Returns the x,y,z coordinates for each of the three points that make up
a BezierTriple (B{deprecated}). See the L{BezTriple.vec} attribute.
@rtype: list consisting of 3 lists of 3 floats
@return: handle1, knot, handle2
"""

468
source/blender/python/api2_2x/doc/Ipo.py
View File

@@ -5,31 +5,66 @@ The Blender.Ipo submodule
B{New}:
- Ipo updates to both the program and Bpython access.
- access to Blender's new Ipo driver capabilities .
- access to Blender's new Ipo driver capabilities.
- Ipo now supports the mapping operator [] to access IpoCurves
This module provides access to the Ipo Data in Blender. An Ipo is composed of
several IpoCurves.
A datatype is defined : IpoCurve type. The member functions of this data type
are given below.
several IpoCurves, and an IpoCurve are composed of several BezTriples.
Example::
import Blender
ob = Blender.Ipo.Get('ipo') # retrieves an Ipo object
ob.setName('ipo1')
print ob.name
print ipo.getRctf()
ipo.setRctf(1,2,3,4)
from Blender import Ipo
ob = Ipo.Get('ObIpo') # retrieves an Ipo object
ob.name = 'ipo1' # change the Ipo's name
icu = ipo[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
icu[Ipo.OB_lOCX] = None # delete the ipo curve
@type HandleTypes: readonly dictionary
@var HandleTypes: The available BezTriple handle types.
- FREE - handle has no constrints
- AUTO - completely constrain handle based on knot position
- VECT - constraint handle to line between current and neighboring knot
- ALIGN - constrain handle to lie in a straight line with knot's other
handle
- AUTOANIM - constrain IPO handles to be horizontal on extremes
Each type of Ipo has different types Ipocurves. With the exception of Shape
Key Ipos, constants are used to specify all Ipocurves. There are two ways
to tell which Ipo curves go with which Ipo type:
- all constants start with a two-character identifier for their Ipo type;
for example, "OB_LOCX" is the LocX curve for an Object Ipo
- each Ipo now has a read-only attribute L{Ipo.curveConsts}, which returns
the valid Ipo curve types for that specific Ipo
The valid IpoCurve constants are:
1. Material Ipo: MA_R, MA_G, MA_B, MA_SPECR, MA_SPECG, MA_SPECB,
MA_MIRR, MA_MIRG, MA_MIRB, MA_REF, MA_ALPHA, MA_EMIT, MA_AMB,
MA_SPEC, MA_HARD, MA_SPTRA, MA_IOR, MA_MODE, MA_HASIZE, MA_TRANSLU,
MA_RAYMIR, MA_FRESMIR, MA_FRESMIRI, MA_FRESTRA, MA_FRESTRAI,
MA_TRAGLOW, MA_OFSX, MA_OFSY, MA_OFSZ, MA_SIZEX, MA_SIZEY, MA_SIZEZ,
MA_TEXR, MA_TEXG, MA_TEXB, MA_DEFVAR, MA_COL, MA_NOR, MA_VAR, MA_DISP
2. Lamp Ipo: LA_ENERG, LA_R, LA_G, LA_B, LA_DIST, LA_SPOSI, LA_SPOBL,
LA_QUAD1, LA_QUAD2, LA_HAINT, LA_OFSX, LA_OFSY, LA_OFSZ, LA_SIZEX,
LA_SIZEY, LA_SIZEZ, LA_TEXR, LA_TEXG, LA_TEXB, LA_DEFVAR, LA_COL
3. World Ipo: WO_HORR, WO_HORG, WO_HORB, WO_ZENR, WO_ZENG, WO_ZENB,
WO_EXPOS, WO_MISI, WO_MISDI, WO_MISSTA, WO_MISHI, WO_STARR,
WO_STARB, WO_STARG, WO_STARDI, WO_STARSI, WO_OFSX, WO_OFSY,
WO_OFSZ, WO_SIZEX, WO_SIZEY, WO_SIZEZ, WO_TEXR, WO_TEXG,
WO_TEXB, WO_DEFVAR, WO_COL, WO_NOR, WO_VAR
4. Camera Ipo: CA_LENS, CA_CLSTA, CA_CLEND, CA_APERT, CA_FDIST
5. Object Ipo: OB_LOCX, OB_LOCY, OB_LOCZ, OB_DLOCX, OB_DLOCY, OB_DLOCZ,
OB_ROTX, OB_ROTY, OB_ROTZ, OB_DROTX, OB_DROTY, OB_DROTZ,
OB_SIZEX, OB_SIZEY, OB_SIZEZ, OB_DSIZEX, OB_DSIZEY, OB_DSIZEZ,
OB_LAYER, OB_TIME, OB_COLR, OB_COLG, OB_COLB, OB_COLA,
OB_FSTRENG, OB_FFALL, OB_RDAMP, OB_DAMPING, OB_PERM
6. Curve Ipo: CU_SPEED
7. Constraint Ipo: CO_INF
8. Texture Ipo: TE_NSIZE, TE_NDEPTH, TE_NTYPE, TE_TURB, TE_VNW1, TE_VNW2,
TE_VNW3, TE_VNW4, TE_MINKMEXP, TE_DISTM, TE_COLT, TE_ISCALE,
TE_DISTA, TE_MGTYPE, TE_MGH, TE_LACU, TE_OCT, TE_MGOFF,
TE_MGGAIN, TE_NBASE1, TE_NBASE2, TE_COLR, TE_COLG, TE_COLB,
TE_BRIGHT, TE_CONTRAS
9. Pose/Action Ipo: PO_LOCX, PO_LOCY, PO_LOCZ, PO_SIZEX, PO_SIZEY,
PO_SIZEZ, PO_QUATW, PO_QUATX, PO_QUATY, PO_QUATZ
10. Sequence Ipo: SQ_FAC
Shape Key Ipos are handled differently from other Ipos. The user can rename
the curves, so string are used to access them instead of constants. The
L{Ipo.curveConsts} attribute for Shape Key Ipos returns a list of all defined
key names.
"""
def New (type, name):
@@ -53,34 +88,159 @@ def Get (name = None):
@rtype: Blender Ipo or a list of Blender Ipos
@return: It depends on the 'name' parameter:
- (name): The Ipo with the given name;
- (): A list with all Ipos in the current scene.
- (): A list with all Ipos in the current scene.
"""
class Ipo:
"""
The Ipo object
==============
This object gives access to generic data from all objects in Blender.
It has no attributes.
This object gives access to Ipo data from all objects in Blender.
@Note: Blender Materials, Lamps and Worlds have I{texture channels} which
allow the user to assign textures to them. The Blender Ipo Window allows
the user to access the IpoCurves for these channels by specifying a number
between 0 and 9 (the number appears next to the Ipo type in the window
header). Prior to Version 2.42, the BPy API did not allow users to access
these texture channels in a predictable manner. A new attribute named
L{channel} was added to the API in Version 2.42 to correct this problem.
The current channel setting has an effect on the operators B{[]}, B{len()}
and others. For example, suppose a Material has three IpoCurves
(R, G, and B), and two texture channels (numbered 0 and 1), and furthermore
channel 0 has one Ipocurve (Col). The IpoCurve Col can only be
"seen" through the API when B{ipo.channel} is 0. Setting B{ipo.channel} to
1 will cause this curve to be ignored by B{len(ipo)}::
from Blender import Ipo
ipo = Ipo.Get('MatIpo')
for channel in xrange(2):
ipo.channel = channel
print 'channel is',channel
print ' len is',len(ipo)
names = dict([(x[1],x[0]) for x in ipo.curveConsts.items()])
for curve in [Ipo.MA_R,Ipo.MA_COL]:
print ' ',names[curve],'is',curve in ipo
will output::
channel is 0
len is 4
MA_R is True
MA_COL is True
channel is 1
len is 3
MA_R is True
MA_COL is False
@ivar name: The Ipo datablock's name
@type name: string
@ivar curves: Ipo curves currently defined for the Ipo.
@type curves: list of Ipocurves.
@ivar curveConsts: The valid Ipo curves for this Ipo. These can be used
by the [] mapping operator. The value
depends on the Ipo curve type. If the Ipo is any type other than a Key or
Shape Ipo, this attribute returns a set of constants that can be
used to specify a particular curve. For Key or Shape Ipos, the attribute
returns a list of all defined keys by name.
@type curveConsts: constant or list of strings. Read-only.
@ivar channel: the current texture channel for Blender object which support
textures (materials, lamps and worlds). Returns None if the Ipo does
not support texture channels. Value must be in the range [0,9].
@type channel: int or None
"""
def __contains__():
"""
The "in" operator for Ipos. It returns B{True} if the specified
IpoCurve exists for the Ipo. This operator B{should not} be used to
test for whether a curve constant is valid for a particular Ipo type.
Many constants for different Ipo types have the same value, and it is
the constant's value used internally.
No exceptions are raised if the argument is not a valid curve constant or
or string, nor does the operator return B{True} when the curve
constant is valid but does not currently exist. As such, it should only be
used to test for specific curves when the Ipo type is known::
ipo = Object.Get('Cube').ipo # get Object-type Ipo
if ipo:
print Ipo.OB_LOCX in ipo # prints "True" if 'LocX' curve exists
print Ipo.MA_R in ipo # also prints "True" since MA_R and OB_LOCX are have the same value
print 'hiccup' in ipo # always prints "False" since argument is not a constant
@return: see above.
@rtype: Boolean
"""
def __getitem__():
"""
This operator is similar to the Python dictionary mapping operator [],
except that the user cannot assign arbitrary keys. Each Ipo type has
a pre-defined set of IpoCurves which may or may not exist at a given time. This operator
will either return an IpoCurve object if the specified curve exists,
return None if the curve does not exists, or throws a KeyError exception
if the curve is not valid for this Ipo type.
@return: an IpoCurve object if it exists
@rtype: IpoCurve or None
@raise KeyError: an undefined IpoCurve was specified for the Ipo
"""
def __iter__():
"""
Iterator for Ipos. It returns all the defined IpoCurve objects associated
with the Ipo. For example::
from Blender import Ipo
ipo = Ipo.Get()
if len(ipo) > 0:
ipo = ipo[0]
print 'ipo name is',ipo.name
for icu in ipo:
print ' curve name is',icu.name
might result in::
ipo name is ObIpo
curve name is LocX
curve name is LocY
curve name is LocZ
@return: an IpoCurve object
@rtype: IpoCurve
"""
def __len__():
"""
Returns the number of curves defined for the Ipo.
@return: number of defined IpoCurves
@rtype: int
"""
def getName():
"""
Gets the name of the Ipo.
Gets the name of the Ipo (B{deprecated}). See the L{name} attribute.
@rtype: string
@return: the name of the Ipo.
"""
def setName(newname):
"""
Sets the name of the Ipo (B{deprecated}). See the L{name} attribute.
@type newname: string
@rtype: None
@return: None
"""
def getCurves():
"""
Gets all the IpoCurves of the Ipo.
Gets all the IpoCurves of the Ipo (B{deprecated}). Use the
L{iterator operator []<__iter__>} instead.
@rtype: list of IpoCurves
@return: A list (possibly void) containing all the IpoCurves associated to the Ipo object.
@return: A list (possibly empty) containing all the IpoCurves associated
to the Ipo object.
"""
def getCurve(curve):
"""
Return the specified IpoCurve. If the curve does not exist in the Ipo,
Return the specified IpoCurve (B{deprecated}). Use the L{mapping
operator B{[]}<__getitem__>} instead.
If the curve does not exist in the Ipo,
None is returned. I{curve} can be either a string or an integer,
denoting either the name of the Ipo curve or its internal adrcode.
The possible Ipo curve names are:
@@ -111,8 +271,8 @@ class Ipo:
9. Sequence Ipo: Fac.
10. Constraint Ipo: Inf.
The adrcode for the Ipo curve can also be given; currently this is the
only way to access curves for Key Ipos. The adrcodes for Key Ipo are
The adrcode for the Ipo curve can also be given; this is useful for
accessing curves for Shape Key Ipos. The adrcodes for Shape Key Ipo are
numbered consecutively starting at 0.
@type curve : string or int
@rtype: IpoCurve object
@@ -158,20 +318,18 @@ class Ipo:
def delCurve(curvename):
"""
Delete an existing curve from the Ipo object. See addCurve() for possible values for curvename.
Delete an existing curve from the Ipo object (B{deprecated}).
Use the L{mapping operator B{[]}<__getitem__>} instead::
from Blender import Ipo
ipo = Ipo.Get('ObIpo')
ipo[Ipo.LOCX] = None
@type curvename : string
@rtype: None
@return: None.
"""
def setName(newname):
"""
Sets the name of the Ipo.
@type newname: string
@rtype: None
@return: None
"""
def getBlocktype():
"""
Gets the blocktype of the Ipo.
@@ -209,7 +367,8 @@ class Ipo:
def getNcurves():
"""
Gets the number of curves of the Ipo.
Gets the number of curves of the Ipo (B{deprecated}). Use
L{len(ipo)<__len__>} instead.
@rtype: int
@return: the number of curve of the Ipo.
"""
@@ -223,7 +382,8 @@ class Ipo:
def getBeztriple(curvepos,pointpos):
"""
Gets a beztriple of the Ipo.
Gets a beztriple of the Ipo (B{deprecated}). B{Note}:
Use L{IpoCurve.bezierPoints<IpoCurve.IpoCurve.bezierPoints>} instead.
@type curvepos: int
@param curvepos: the position of the curve in the Ipo.
@type pointpos: int
@@ -234,7 +394,10 @@ class Ipo:
def setBeztriple(curvepos,pointpos,newbeztriple):
"""
Sets the beztriple of the Ipo.
Sets the beztriple of the Ipo (B{deprecated}). B{Note}: use
L{IpoCurve.bezierPoints<IpoCurve.IpoCurve.bezierPoints>} to get a
BezTriple point, then use the
L{BezTriple} API to set the point's attributes.
@type curvepos: int
@param curvepos: the position of the curve in the Ipo.
@type pointpos: int
@@ -248,7 +411,7 @@ class Ipo:
def getCurveCurval(curvepos):
"""
Gets the current value of a curve of the Ipo (B{deprecated}). B{Note}:
new scripts should use L{IpoCurve.evaluate()}.
new scripts should use L{IpoCurve.evaluate()<IpoCurve.IpoCurve.evaluate>}.
@type curvepos: int or string
@param curvepos: the position of the curve in the Ipo or the name of the
curve
@@ -259,229 +422,14 @@ class Ipo:
def EvaluateCurveOn(curvepos,time):
"""
Gets the value at a specific time of a curve of the Ipo (B{deprecated}).
B{Note}: new scripts should use L{IpoCurve.evaluate()}.
B{Note}: new scripts should use
L{IpoCurve.evaluate()<IpoCurve.IpoCurve.evaluate>}.
@type curvepos: int
@param curvepos: the position of the curve in the Ipo.
@type time: float
@param time: the desired time.
@rtype: float
@return: the current value of the selected curve of the Ipo at the given
time.
time.
"""
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= on, 0= off.
@type driver: int
@ivar driverObject: Object used to drive the Ipo curve.
@type driverObject: Blender Object or None
@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
@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
"""
def setExtrapolation(extendmode):
"""
Sets the extend mode of the curve.
@type extendmode: string
@param extendmode: the extend mode of the curve.
Can be Constant, Extrapolation, Cyclic or Cyclic_extrapolation.
@rtype: None
@return: None
@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's L{bezierPoints} attribute::
ipo = Blender.Object.Get('Cube').ipo
icu = ipo.getCurves('LocX')
endtime,endvalue = icu.bezierPoints[-1].pt
"""
def getExtrapolation():
"""
Gets the extend mode of the curve.
@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.
@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.
@rtype: string
@return: the interpolation type of the curve. Can be Constant, Bezier, or Linear.
"""
def addBezier(coordlist):
"""
Adds a Bezier point to a curve.
@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. This 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 Ipo curve.
@rtype: list of BezTriples
@return: the points of the Ipo curve.
"""
def evaluate( time ):
"""
Compute the value of the Ipo curve at a particular time.
@type time: float
@param time: value along the X axis
@rtype: float
@return: the Y value of the curve at the given time
"""
class BezTriple:
"""
The BezTriple object
====================
This object gives access to generic data from all BezTriple objects in
Blender.
@ivar pt : the [x,y] coordinates for knot point of this BezTriple. After
changing coordinates of a Ipo curve, it is advisable to call
L{IpoCurve.recalc()} to update the curve.
@type pt: list of two floats
@ivar vec : a list of the 3 points [ handle, knot, handle ] that comprise a
BezTriple, with each point composed of a list [x,y,z] of floats. The list
looks like [ [H1x, H1y, H1z], [Px, Py, Pz], [H2x, H2y, H2z] ].
Example::
# where bt is of type BezTriple
# and h1, p, and h2 are lists of 3 floats
h1, p, h2 = bt.vec
@type vec: list of points
@ivar tilt: the tilt/alpha value for the point
@type tilt: float
@ivar hide: the visibility status of the knot. B{Note}: true/nonzero means
I{not} hidden. B{Note}: primarily intended for curves; not a good idea to
hide IPO control points.
@type hide: int
@ivar handleTypes: the types of the point's two handles. See
L{HandleTypes} for a complete description.
@type handleTypes list of two ints
@ivar selects: the select status for [handle, knot, handle]. True/nonzero
if the point is selected.
@type selects: list of three ints
@ivar weight: the weight assigned to the control point. Useful for
softbodies and possibly others.
@type weight: float
"""
def __init__(coords):
"""
Create a new BezTriple object.
@type coords: sequence of three or nine floats
@param coords: the coordinate values for the new control point. If three
floats are given, then the handle values are automatically generated.
@rtype: BezTriple
@return: a new BezTriple object
"""
def getPoints():
"""
Returns the x,y coordinates of the Bezier knot point (B{deprecated}).
See the L{BezTriple.pt} attribute.
@rtype: list of floats
@return: list of the x and y coordinates of the Bezier point.
"""
def setPoints(newval):
"""
Sets the x,y coordinates of the Bezier knot point (B{deprecated}).
See the L{BezTriple.pt} attribute.
@type newval: tuple of 2 floats
@param newval: the x and y coordinates of the new Bezier point.
@rtype: None
@return: None
"""
def getTriple():
"""
Returns the x,y,z coordinates for each of the three points that make up
a BezierTriple (B{deprecated}). See the L{BezTriple.vec} attribute.
@rtype: list consisting of 3 lists of 3 floats
@return: handle1, knot, handle2
"""

223
source/blender/python/api2_2x/doc/IpoCurve.py Normal file
View File

@@ -0,0 +1,223 @@
# 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.
Example::
import Blender
ob = Blender.Ipo.Get('ObIpo') # retrieves an Ipo object
ob.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= on, 0= off.
@type driver: int
@ivar driverObject: Object used to drive the Ipo curve.
@type driverObject: Blender Object or None
@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
@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 (B{deprecated}). B{Note}:
new scripts should use B{del icu[index]} instead.
@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 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
"""