Newer
Older
# Blender.Curve module and the Curve PyType object
"""
The Blender.Curve submodule.
Curve Data
==========
This module provides access to B{Curve Data} objects in Blender.
A Blender Curve can consist of multiple curves. Try converting a Text object to a Curve to see an example of this. Each curve is of
type Bezier or Nurb. The underlying curves can be accessed with
the [] operator. Operator [] returns an object of type CurNurb.
The Curve module also supports the Python iterator interface. This means you can access the curves in a Curve or the control points in a CurNurb using a python for statement.
Add a Curve to a Scene Example::
from Blender import Curve, Object, Scene
c = Curve.New() # create new curve data
cur = Scene.getCurrent() # get current scene
ob = Object.New('Curve') # make curve object
ob.link(c) # link curve data with this object
cur.link(ob) # link object into scene
Iterator Example::
ob = Object.GetSelected()[0]
curve = ob.getData()
for cur in curve:
print type( cur ), cur
for point in cur:
print type( point ), point
"""
def New ( name = 'CurData'):
"""
Create a new Curve Data object.
@type name: string
@param name: The Curve Data name.
@rtype: Blender Curve
@return: The created Curve Data object.
"""
def Get (name = None):
"""
Get the Curve Data object(s) from Blender.
@type name: string
@param name: The name of the Curve Data.
@rtype: Blender Curve or a list of Blender Curves
@return: It depends on the 'name' parameter:
- (name): The Curve Data object with the given name;
- (): A list with all Curve Data objects in the current scene.
"""
class Curve:
"""
The Curve Data object
=====================
This object gives access to Curve-specific data in Blender.
@cvar name: The Curve Data name.
@cvar pathlen: The Curve Data path length.
@cvar totcol: The Curve Data maximal number of linked materials.
@cvar flag: The Curve Data flag value; see function getFlag for the semantics.
@cvar bevresol: The Curve Data bevel resolution.
@cvar resolu: The Curve Data U-resolution.
@cvar resolv: The Curve Data V-resolution.
@cvar width: The Curve Data width.
@cvar ext1: The Curve Data extent 1(for bevels).
@cvar ext2: The Curve Data extent2 (for bevels).
@cvar loc: The Curve Data location(from the center).
@cvar rot: The Curve Data rotation(from the center).
@cvar size: The Curve Data size(from the center).
"""
def getName():
"""
Get the name of this Curve Data object.
@rtype: string
"""
def setName(name):
"""
Set the name of this Curve Data object.
@rtype: PyNone
@type name: string
@param name: The new name.
"""
"""
Get this Curve's path length.
@rtype: int
@return: the path length.
"""
"""
Set this Curve's path length.
@rtype: PyNone
@type len: int
@param len: the new curve's length.
"""
def getTotcol():
"""
Get the number of materials linked to the Curve.
@rtype: int
@return: number of materials linked.
"""
def setTotcol(totcol):
"""
Set the number of materials linked to the Curve.
@rtype: PyNone
@type totcol: int
@param totcol: number of materials linked.
"""
Get the Curve flag value.
This item is a bitfield whose value is a combination of the following parameters.
- Bit 0 : "3D" is set
"""
Set the Curve flag value. The flag corresponds to the Blender settings for 3D, Front, Back, CurvePath and CurveFollow. This parameter is a bitfield.
@rtype: PyNone
@type val: integer bitfield
@param val : The Curve's flag bits. See L{getFlag} for the meaning of the individual bits.
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
"""
def getBevresol():
"""
Get the Curve's bevel resolution value.
@rtype: float
"""
def setBevresol(bevelresol):
"""
Set the Curve's bevel resolution value.
@rtype: PyNone
@type bevelresol: float
@param bevelresol: The new Curve's bevel resolution value.
"""
def getResolu():
"""
Get the Curve's U-resolution value.
@rtype: float
"""
def setResolu(resolu):
"""
Set the Curve's U-resolution value.
@rtype: PyNone
@type resolu: float
@param resolu: The new Curve's U-resolution value.
"""
def getResolv():
"""
Get the Curve's V-resolution value.
@rtype: float
"""
def setResolv(resolv):
"""
Set the Curve's V-resolution value.
@rtype: PyNone
@type resolv: float
@param resolv: The new Curve's V-resolution value.
"""
def getWidth():
"""
Get the Curve's width value.
@rtype: float
"""
def setWidth(width):
"""
Set the Curve's width value.
@rtype: PyNone
@type width: float
@param width: The new Curve's width value.
"""
def getExt1():
"""
Get the Curve's ext1 value.
@rtype: float
"""
def setExt1(ext1):
"""
Set the Curve's ext1 value.
@rtype: PyNone
@type ext1: float
@param ext1: The new Curve's ext1 value.
"""
def getExt2():
"""
Get the Curve's ext2 value.
@rtype: float
"""
def setExt2(ext2):
"""
Set the Curve's ext2 value.
@rtype: PyNone
@type ext2: float
@param ext2: The new Curve's ext2 value.
"""
"""
Get the curve's control point value.
@type numcurve: int
@type numpoint: int
- type Bezier : a list of three coordinates
- type Nurb : a list of nine coordinates.
"""
"""
Set the Curve's controlpoint value.
@rtype: PyNone
@type controlpoint: list
@param numcurve: index for spline in Curve, starting from 0
@param numpoint: index for point in spline, starting from 0
@param controlpoint: The new controlpoint value.
See L{getControlPoint} for the length of the list.
"""
def appendPoint( numcurve, new_control_point ):
"""
add a new control point to the indicated curve.
@rtype: PyNone
@type numcurve: int
@type new_control_point: list xyzw or BezTriple
@param numcurve: index for spline in Curve, starting from 0
@param new_control_point: depends on curve's type.
- type Bezier: a BezTriple
- type Nurb: a list of four floats for the xyzw values
@raise AttributeError: throws exception if numcurve is out of range.
"""
def appendNurb( new_point ):
"""
add a new curve to this Curve. The new point is added to the new curve. Blender does not support a curve with zero points. The new curve is added to the end of the list of curves in the Curve.
@rtype: PyNone
@return: PyNone
@type new_point: BezTriple or list of xyzw coordinates for a Nurb curve.
@param new_point: see L{CurNurb.append} for description of parameter.
"""
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
def getLoc():
"""
Get the curve's location value.
@rtype: a list of 3 floats.
"""
def setLoc(location):
"""
Set the curve's location value.
@rtype: PyNone
@type location: list[3]
@param location: The new Curve's location values.
"""
def getRot():
"""
Get the curve's rotation value.
@rtype: a list of 3 floats.
"""
def setRot(rotation):
"""
Set the Curve's rotation value.
@rtype: PyNone
@type rotation: list[3]
@param rotation: The new Curve's rotation values.
"""
def getSize():
"""
Get the curve's size value.
@rtype: a list of 3 floats.
"""
def setSize(size):
"""
Set the curve size value.
@rtype: PyNone
@type size: list[3]
@param size: The new Curve's size values.
"""
def getMaterials():
"""
Returns a list of materials assigned to the Curve.
@rtype: list of Material Objects
@return: list of Material Objects assigned to the Curve.
"""
def update():
"""
Updates display list for a Curve.
Used after making changes to control points.
You B{must} use this if you want to see your changes!
@rtype: PyNone
@return: PyNone
"""
def isNurb( curve_num):
"""
method used to determine whether a CurNurb is of type Bezier or of type Nurb.
@rtype: integer
@return: Zero of curve is type Bezier, One if curve is of type Nurb.
@type curve_num: integer
@param curve_num: zero-based index into list of curves in this Curve.
@raise AttributeError: throws exception if curve_num is out of range.
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
"""
class CurNurb:
"""
The CurNurb Object
==================
This object provides access to the control points of the curves that make up a Blender Curve.
The CurNurb supports the python iterator protocol which means you can use a python for statement to access the points in a curve.
The CurNurb also supports the sequence protocol which means you can access the control points of a CurNurb using the [] operator.
"""
def append( new_point ):
"""
Appends a new point to a curve. This method appends points to both Bezier and Nurb curves. The type of the argument must match the type of the curve. An empty curve will assume the type of the first appended point.
@rtype: PyNone
@return: PyNone
@type new_point: BezTriple or list of 4 floats
@param new_point: the new point to be appended to the curve. The new point can be either a BezTriple type or a list of 4 floats in x,y,z,w format for a Nurb curve.
"""
def setMatIndex( index ):
"""
Sets the Material index for this CurNurb.
@rtype: PyNone
@return: PyNone
@type index: integer
@param index: the new value for the Material number of this CurNurb. No range checking is done.
"""
def getMatIndex():
"""
Returns the Material index for this CurNurb.
@rtype: integer
@return: integer
"""
def isNurb():
"""
Boolean method used to determine whether a CurNurb is of type Bezier or of type Nurb.
@rtype: boolean
@return: True or False
"""