a5f8b20d8a22e7f73c2f4b41311b73098ac2593d
[blender-staging.git] / release / scripts / ui / properties_data_modifier.py
1 # This software is distributable under the terms of the GNU
2 # General Public License (GPL) v2, the text of which can be found at
3 # http://www.gnu.org/copyleft/gpl.html. Installing, importing or otherwise
4 # using this module constitutes acceptance of the terms of this License.
5
6
7 import bpy
8
9 class DataButtonsPanel(bpy.types.Panel):
10     bl_space_type = 'PROPERTIES'
11     bl_region_type = 'WINDOW'
12     bl_context = "modifier"
13
14 class DATA_PT_modifiers(DataButtonsPanel):
15     bl_label = "Modifiers"
16
17     def draw(self, context):
18         layout = self.layout
19
20         ob = context.object
21
22         row = layout.row()
23         row.item_menu_enumO("object.modifier_add", "type")
24         row.itemL()
25
26         for md in ob.modifiers:
27             box = layout.template_modifier(md)
28             if box:
29                 # match enum type to our functions, avoids a lookup table.
30                 getattr(self, md.type)(box, ob, md)
31
32     # the mt.type enum is (ab)used for a lookup on function names
33     # ...to avoid lengthy if statements
34     # so each type must have a function here.
35
36     def ARMATURE(self, layout, ob, md):
37         layout.itemR(md, "object")
38
39         split = layout.split(percentage=0.5)
40         split.itemL(text="Vertex Group:")
41         sub = split.split(percentage=0.7)
42         sub.item_pointerR(md, "vertex_group", ob, "vertex_groups", text="")
43         subsub = sub.row()
44         subsub.active = md.vertex_group
45         subsub.itemR(md, "invert")
46
47         layout.itemS()
48
49         split = layout.split()
50
51         col = split.column()
52         col.itemL(text="Bind To:")
53         col.itemR(md, "use_vertex_groups", text="Vertex Groups")
54         col.itemR(md, "use_bone_envelopes", text="Bone Envelopes")
55
56         col = split.column()
57         col.itemL(text="Deformation:")
58         col.itemR(md, "quaternion")
59         col.itemR(md, "multi_modifier")
60
61     def ARRAY(self, layout, ob, md):
62         layout.itemR(md, "fit_type")
63         if md.fit_type == 'FIXED_COUNT':
64             layout.itemR(md, "count")
65         elif md.fit_type == 'FIT_LENGTH':
66             layout.itemR(md, "length")
67         elif md.fit_type == 'FIT_CURVE':
68             layout.itemR(md, "curve")
69
70         layout.itemS()
71
72         split = layout.split()
73
74         col = split.column()
75         col.itemR(md, "constant_offset")
76         sub = col.column()
77         sub.active = md.constant_offset
78         sub.itemR(md, "constant_offset_displacement", text="")
79
80         col.itemS()
81
82         col.itemR(md, "merge_adjacent_vertices", text="Merge")
83         sub = col.column()
84         sub.active = md.merge_adjacent_vertices
85         sub.itemR(md, "merge_end_vertices", text="First Last")
86         sub.itemR(md, "merge_distance", text="Distance")
87
88         col = split.column()
89         col.itemR(md, "relative_offset")
90         sub = col.column()
91         sub.active = md.relative_offset
92         sub.itemR(md, "relative_offset_displacement", text="")
93
94         col.itemS()
95
96         col.itemR(md, "add_offset_object")
97         sub = col.column()
98         sub.active = md.add_offset_object
99         sub.itemR(md, "offset_object", text="")
100
101         layout.itemS()
102
103         col = layout.column()
104         col.itemR(md, "start_cap")
105         col.itemR(md, "end_cap")
106
107     def BEVEL(self, layout, ob, md):
108         row = layout.row()
109         row.itemR(md, "width")
110         row.itemR(md, "only_vertices")
111
112         layout.itemL(text="Limit Method:")
113         layout.row().itemR(md, "limit_method", expand=True)
114         if md.limit_method == 'ANGLE':
115             layout.itemR(md, "angle")
116         elif md.limit_method == 'WEIGHT':
117             layout.row().itemR(md, "edge_weight_method", expand=True)
118
119     def BOOLEAN(self, layout, ob, md):
120         layout.itemR(md, "operation")
121         layout.itemR(md, "object")
122
123     def BUILD(self, layout, ob, md):
124         split = layout.split()
125
126         col = split.column()
127         col.itemR(md, "start")
128         col.itemR(md, "length")
129
130         col = split.column()
131         col.itemR(md, "randomize")
132         sub = col.column()
133         sub.active = md.randomize
134         sub.itemR(md, "seed")
135
136     def CAST(self, layout, ob, md):
137         layout.itemR(md, "cast_type")
138         layout.itemR(md, "object")
139         if md.object:
140             layout.itemR(md, "use_transform")
141
142         flow = layout.column_flow()
143         flow.itemR(md, "x")
144         flow.itemR(md, "y")
145         flow.itemR(md, "z")
146         flow.itemR(md, "factor")
147         flow.itemR(md, "radius")
148         flow.itemR(md, "size")
149
150         layout.itemR(md, "from_radius")
151
152         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
153
154     def CLOTH(self, layout, ob, md):
155         layout.itemL(text="See Cloth panel.")
156
157     def COLLISION(self, layout, ob, md):
158         layout.itemL(text="See Collision panel.")
159
160     def CURVE(self, layout, ob, md):
161         layout.itemR(md, "object")
162         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
163         layout.itemR(md, "deform_axis")
164
165     def DECIMATE(self, layout, ob, md):
166         layout.itemR(md, "ratio")
167         layout.itemR(md, "face_count")
168
169     def DISPLACE(self, layout, ob, md):
170         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
171         layout.itemR(md, "texture")
172         layout.itemR(md, "midlevel")
173         layout.itemR(md, "strength")
174         layout.itemR(md, "direction")
175         layout.itemR(md, "texture_coordinates")
176         if md.texture_coordinates == 'OBJECT':
177             layout.itemR(md, "texture_coordinate_object", text="Object")
178         elif md.texture_coordinates == 'UV' and ob.type == 'MESH':
179             layout.item_pointerR(md, "uv_layer", ob.data, "uv_textures")
180
181     def EDGE_SPLIT(self, layout, ob, md):
182         split = layout.split()
183
184         col = split.column()
185         col.itemR(md, "use_edge_angle", text="Edge Angle")
186         sub = col.column()
187         sub.active = md.use_edge_angle
188         sub.itemR(md, "split_angle")
189
190         col = split.column()
191         col.itemR(md, "use_sharp", text="Sharp Edges")
192
193     def EXPLODE(self, layout, ob, md):
194         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
195         layout.itemR(md, "protect")
196
197         flow = layout.column_flow(2)
198         flow.itemR(md, "split_edges")
199         flow.itemR(md, "unborn")
200         flow.itemR(md, "alive")
201         flow.itemR(md, "dead")
202
203         layout.itemO("object.explode_refresh", text="Refresh");
204
205     def FLUID_SIMULATION(self, layout, ob, md):
206         layout.itemL(text="See Fluid panel.")
207
208     def HOOK(self, layout, ob, md):
209         col = layout.column()
210         col.itemR(md, "object")
211         if md.object and md.object.type == 'ARMATURE':
212             layout.item_pointerR(md, "subtarget", md.object.data, "bones", text="Bone")
213
214         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
215
216         split = layout.split()
217         split.itemR(md, "falloff")
218         split.itemR(md, "force", slider=True)
219
220         layout.itemS()
221
222         row = layout.row()
223         row.itemO("object.hook_reset", text="Reset")
224         row.itemO("object.hook_recenter", text="Recenter")
225
226         if ob.mode == 'EDIT':
227             row = layout.row()
228             row.itemO("object.hook_select", text="Select")
229             row.itemO("object.hook_assign", text="Assign")
230
231     def LATTICE(self, layout, ob, md):
232         layout.itemR(md, "object")
233         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
234
235     def MASK(self, layout, ob, md):
236         layout.itemR(md, "mode")
237         if md.mode == 'ARMATURE':
238             layout.itemR(md, "armature")
239         elif md.mode == 'VERTEX_GROUP':
240             layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
241         layout.itemR(md, "inverse")
242
243     def MESH_DEFORM(self, layout, ob, md):
244         layout.itemR(md, "object")
245         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
246         layout.itemR(md, "invert")
247
248         layout.itemS()
249
250         if md.is_bound:
251             layout.itemO("object.meshdeform_bind", text="Unbind")
252         else:
253             layout.itemO("object.meshdeform_bind", text="Bind")
254             row = layout.row()
255             row.itemR(md, "precision")
256             row.itemR(md, "dynamic")
257
258     def MIRROR(self, layout, ob, md):
259         layout.itemR(md, "merge_limit")
260         split = layout.split()
261
262         col = split.column()
263         col.itemR(md, "x")
264         col.itemR(md, "y")
265         col.itemR(md, "z")
266
267         col = split.column()
268         col.itemL(text="Textures:")
269         col.itemR(md, "mirror_u")
270         col.itemR(md, "mirror_v")
271
272         col = split.column()
273         col.itemR(md, "clip", text="Do Clipping")
274         col.itemR(md, "mirror_vertex_groups", text="Vertex Group")
275
276         layout.itemR(md, "mirror_object")
277
278     def MULTIRES(self, layout, ob, md):
279         layout.itemR(md, "subdivision_type")
280
281         row = layout.row()
282         row.itemO("object.multires_subdivide", text="Subdivide")
283         row.itemO("object.multires_higher_levels_delete", text="Delete Higher")
284
285         layout.itemR(md, "level")
286
287     def PARTICLE_INSTANCE(self, layout, ob, md):
288         layout.itemR(md, "object")
289         layout.itemR(md, "particle_system_number")
290
291         flow = layout.column_flow()
292         flow.itemR(md, "normal")
293         flow.itemR(md, "children")
294         flow.itemR(md, "size")
295         flow.itemR(md, "path")
296         if md.path:
297             flow.itemR(md, "keep_shape")
298         flow.itemR(md, "unborn")
299         flow.itemR(md, "alive")
300         flow.itemR(md, "dead")
301         flow.itemL(md, "")
302         if md.path:
303             flow.itemR(md, "axis", text="")
304
305         if md.path:
306             row = layout.row()
307             row.itemR(md, "position", slider=True)
308             row.itemR(md, "random_position", text = "Random", slider=True)
309
310     def PARTICLE_SYSTEM(self, layout, ob, md):
311         layout.itemL(text="See Particle panel.")
312
313     def SHRINKWRAP(self, layout, ob, md):
314         layout.itemR(md, "target")
315         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
316         layout.itemR(md, "offset")
317         layout.itemR(md, "subsurf_levels")
318         layout.itemR(md, "mode")
319         if md.mode == 'PROJECT':
320             layout.itemR(md, "subsurf_levels")
321             layout.itemR(md, "auxiliary_target")
322
323             row = layout.row()
324             row.itemR(md, "x")
325             row.itemR(md, "y")
326             row.itemR(md, "z")
327
328             flow = layout.column_flow()
329             flow.itemR(md, "negative")
330             flow.itemR(md, "positive")
331             flow.itemR(md, "cull_front_faces")
332             flow.itemR(md, "cull_back_faces")
333         elif md.mode == 'NEAREST_SURFACEPOINT':
334             layout.itemR(md, "keep_above_surface")
335
336     def SIMPLE_DEFORM(self, layout, ob, md):
337         layout.itemR(md, "mode")
338         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
339         layout.itemR(md, "origin")
340         layout.itemR(md, "relative")
341         layout.itemR(md, "factor")
342         layout.itemR(md, "limits")
343         if md.mode in ('TAPER', 'STRETCH'):
344             layout.itemR(md, "lock_x_axis")
345             layout.itemR(md, "lock_y_axis")
346
347     def SMOKE(self, layout, ob, md):
348         layout.itemL(text="See Smoke panel.")
349
350     def SMOOTH(self, layout, ob, md):
351         split = layout.split()
352
353         col = split.column()
354         col.itemR(md, "x")
355         col.itemR(md, "y")
356         col.itemR(md, "z")
357
358         col = split.column()
359         col.itemR(md, "factor")
360         col.itemR(md, "repeat")
361
362         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
363
364     def SOFT_BODY(self, layout, ob, md):
365         layout.itemL(text="See Soft Body panel.")
366
367     def SUBSURF(self, layout, ob, md):
368         layout.row().itemR(md, "subdivision_type", expand=True)
369
370         flow = layout.column_flow()
371         flow.itemR(md, "levels", text="Preview")
372         flow.itemR(md, "render_levels", text="Render")
373         flow.itemR(md, "optimal_draw", text="Optimal Display")
374         flow.itemR(md, "subsurf_uv")
375
376     def SURFACE(self, layout, ob, md):
377         layout.itemL(text="See Fields panel.")
378
379     def UV_PROJECT(self, layout, ob, md):
380         if ob.type == 'MESH':
381             layout.item_pointerR(md, "uv_layer", ob.data, "uv_textures")
382             layout.itemR(md, "image")
383             layout.itemR(md, "override_image")
384
385             split = layout.split()
386
387             col = split.column()
388             col.itemL(text="Aspect Ratio:")
389
390             sub = col.column(align=True)
391             sub.itemR(md, "horizontal_aspect_ratio", text="Horizontal")
392             sub.itemR(md, "vertical_aspect_ratio", text="Vertical")
393
394             col = split.column()
395             col.itemL(text="Projectors:")
396
397             sub = col.column(align=True)
398             sub.itemR(md, "num_projectors", text="Number")
399             for proj in md.projectors:
400                 sub.itemR(proj, "object", text="")
401
402     def WAVE(self, layout, ob, md):
403         split = layout.split()
404
405         col = split.column()
406         col.itemL(text="Motion:")
407         col.itemR(md, "x")
408         col.itemR(md, "y")
409         col.itemR(md, "cyclic")
410
411         col = split.column()
412         col.itemR(md, "normals")
413         sub = col.column()
414         sub.active = md.normals
415         sub.itemR(md, "x_normal", text="X")
416         sub.itemR(md, "y_normal", text="Y")
417         sub.itemR(md, "z_normal", text="Z")
418
419         split = layout.split()
420
421         col = split.column()
422         col.itemL(text="Time:")
423         sub = col.column(align=True)
424         sub.itemR(md, "time_offset", text="Offset")
425         sub.itemR(md, "lifetime", text="Life")
426         col.itemR(md, "damping_time", text="Damping")
427
428         col = split.column()
429         col.itemL(text="Position:")
430         sub = col.column(align=True)
431         sub.itemR(md, "start_position_x", text="X")
432         sub.itemR(md, "start_position_y", text="Y")
433         col.itemR(md, "falloff_radius", text="Falloff")
434
435         layout.itemS()
436
437         layout.itemR(md, "start_position_object")
438         layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
439         layout.itemR(md, "texture")
440         layout.itemR(md, "texture_coordinates")
441         if md.texture_coordinates == 'MAP_UV' and ob.type == 'MESH':
442             layout.item_pointerR(md, "uv_layer", ob.data, "uv_textures")
443         elif md.texture_coordinates == 'OBJECT':
444             layout.itemR(md, "texture_coordinates_object")
445
446         layout.itemS()
447
448         flow = layout.column_flow()
449         flow.itemR(md, "speed", slider=True)
450         flow.itemR(md, "height", slider=True)
451         flow.itemR(md, "width", slider=True)
452         flow.itemR(md, "narrowness", slider=True)
453
454 bpy.types.register(DATA_PT_modifiers)