1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
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
|
# Blender.Lattice module and the Lattice PyType object
"""
The Blender.Lattice submodule.
Lattice Object
==============
This module provides access to B{Lattice} object in Blender.
Example::
import Blender
from Blender import Lattice
from Blender.Lattice import *
from Blender import Object
from Blender import Scene
myOb = Object.New('Lattice')
myLat = Lattice.New()
myLat.setPartitions(5,5,5)
myLat.setKeyTypes(LINEAR, CARDINAL, BSPLINE)
myLat.setMode(OUTSIDE)
for y in range(125):
vec = myLat.getPoint(y)
co1 = vec[0] + vec[0] / 5
co2 = vec[1] - vec[2] * 0.3
co3 = vec[2] * 3
myLat.setPoint(y,[co1,co2,co3])
myOb.link(myLat)
mySphere = Object.Get('Sphere')
myOb.makeParent([mySphere])
myLat.applyDeform()
sc = Scene.getCurrent()
sc.link(myOb)
Blender.Redraw()
"""
def New (name = None):
"""
Create a new Lattice object.
Passing a name to this function will name the Lattice
datablock, otherwise the Lattice data will be given a
default name.
@type name: string
@param name: The Lattice name.
@rtype: Blender Lattice
@return: The created Lattice Data object.
"""
def Get (name = None):
"""
Get the Lattice object(s) from Blender.
@type name: string
@param name: The name of the Lattice object.
@rtype: Blender Lattice or a list of Blender Lattices
@return: It depends on the 'name' parameter:
- (name): The Lattice object with the given name;
- (): A list with all Lattice objects in the current scene.
"""
class Lattice:
"""
The Lattice object
==================
This object gives access to Lattices in Blender.
@cvar name: The Lattice name.
@cvar width: The number of x dimension partitions.
@cvar height: The number of y dimension partitions.
@cvar depth: The number of z dimension partitions.
@cvar widthType: The x dimension key type.
@cvar heightType: The y dimension key type.
@cvar depthType: The z dimension key type.
@cvar mode: The current mode of the Lattice.
@cvar latSize: The number of points in this Lattice.
"""
def getName():
"""
Get the name of this Lattice datablock.
@rtype: string
@return: The name of the Lattice datablock.
"""
def setName(name):
"""
Set the name of this Lattice datablock.
@type name: string
@param name: The new name.
"""
def getPartitions():
"""
Gets the number of 'walls' or partitions that the Lattice has
in the x, y, and z dimensions.
@rtype: list of ints
@return: A list corresponding to the number of partitions: [x,y,z]
"""
def setPartitions(x,y,z):
"""
Set the number of 'walls' or partitions that the
Lattice will be created with in the x, y, and z dimensions.
@type x: int
@param x: The number of partitions in the x dimension of the Lattice.
@type y: int
@param y: The number of partitions in the y dimension of the Lattice.
@type z: int
@param z: The number of partitions in the z dimension of the Lattice.
"""
def getKeyTypes():
"""
Returns the deformation key types for the x, y, and z dimensions of the
Lattice.
@rtype: list of strings
@return: A list corresponding to the key types will be returned: [x,y,z]
"""
def setKeyTypes(xType,yType,zType):
"""
Sets the deformation key types for the x, y, and z dimensions of the
Lattice.
There are three key types possible:
- Lattice.CARDINAL
- Lattice.LINEAR
- Lattice.BSPLINE
@type xType: enum constant
@param xType: the deformation key type for the x dimension of the Lattice
@type yType: enum constant
@param yType: the deformation key type for the y dimension of the Lattice
@type zType: enum constant
@param zType: the deformation key type for the z dimension of the Lattice
"""
def getMode():
"""
Returns the current Lattice mode
@rtype: string
@return: A string representing the current Lattice mode
"""
def setMode(modeType):
"""
Sets the current Lattice mode
There are two Lattice modes possible:
- Lattice.GRID
- Lattice.OUTSIDE
@type modeType: enum constant
@param modeType: the Lattice mode
"""
def getPoint(index):
"""
Returns the coordinates of a point in the Lattice by index.
@type index: int
@param index: The index of the point on the Lattice you want returned
@rtype: list of floats
@return: The x,y,z coordiates of the Lattice point : [x,y,z]
"""
def setPoint(index, position):
"""
Sets the coordinates of a point in the Lattice by index.
@type index: int
@param index: The index of the point on the Lattice you want set
@type position: list of floats
@param position: The x,y,z coordinates that you want the point to be: [x,y,z]
"""
def applyDeform(force = False):
"""
@type force: bool
@param force: if True, meshes are not ignored.
Applies the current Lattice deformation to any child objects that have this
Lattice as the parent.
@note: simply parenting to a Lattice and redrawing the screen is enough to
get the deformation done, this applyDeform method is useful when the
script won't call a redraw, like in command line background (GUI-less)
mode.
@note: by default, this method doesn't apply deformations to meshes. This
is because unlike other kinds of objects, meshes store lattice
deformation directly in their vertices and calling this applyDeform
method will apply the deformation a second time, giving double
deformation, which can be a feature (set force = True if you want it) or
much probably an undesired effect.
"""
def insertKey(frame):
"""
Inserts the current state of the Lattice as a new absolute keyframe
B{Example}::
for z in range(5):
for y in range(125):
vec = myLat.getPoint(y)
co1 = vec[0] + vec[2]
co2 = vec[1] - vec[2]
co3 = vec[2] + vec[1]
myLat.setPoint(y,[co1,co2,co3])
w = (z + 1) * 10
myLat.insertKey(w)
myLat.applyDeform()
@type frame: int
@param frame: the frame at which the Lattice will be set as a keyframe
"""
|
