rna data path names which are more likely to break animations.
[blender-staging.git] / release / scripts / modules / rigify / mouth.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2 #
3 #  This program is free software; you can redistribute it and/or
4 #  modify it under the terms of the GNU General Public License
5 #  as published by the Free Software Foundation; either version 2
6 #  of the License, or (at your option) any later version.
7 #
8 #  This program is distributed in the hope that it will be useful,
9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 #  GNU General Public License for more details.
12 #
13 #  You should have received a copy of the GNU General Public License
14 #  along with this program; if not, write to the Free Software Foundation,
15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 # <pep8 compliant>
20
21 import bpy
22 from rna_prop_ui import rna_idprop_ui_prop_get
23 from math import acos, pi
24 from mathutils import Vector
25 from rigify import RigifyError
26 from rigify_utils import copy_bone_simple
27
28 #METARIG_NAMES = ("cpy",)
29 RIG_TYPE = "mouth"
30
31
32 def mark_actions():
33     for action in bpy.data.actions:
34         action.tag = True
35
36 def get_unmarked_action():
37     for action in bpy.data.actions:
38         if action.tag != True:
39             return action
40     return None
41
42 def add_action(name=None):
43     mark_actions()
44     bpy.ops.action.new()
45     action = get_unmarked_action()
46     if name is not None:
47         action.name = name
48     return action
49
50 def addget_shape_key(obj, name="Key"):
51     """ Fetches a shape key, or creates it if it doesn't exist
52     """
53     # Create a shapekey set if it doesn't already exist
54     if obj.data.shape_keys is None:
55         shape = obj.add_shape_key(name="Basis", from_mix=False)
56         obj.active_shape_key_index = 0
57
58     # Get the shapekey, or create it if it doesn't already exist
59     if name in obj.data.shape_keys.keys:
60         shape_key = obj.data.shape_keys.keys[name]
61     else:
62         shape_key = obj.add_shape_key(name=name, from_mix=False)
63
64     return shape_key
65
66
67 def addget_shape_key_driver(obj, name="Key"):
68     """ Fetches the driver for the shape key, or creates it if it doesn't
69         already exist.
70     """
71     driver_path = 'keys["' + name + '"].value'
72     fcurve = None
73     driver = None
74     new = False
75     if obj.data.shape_keys.animation_data is not None:
76         for driver_s in obj.data.shape_keys.animation_data.drivers:
77             if driver_s.data_path == driver_path:
78                 fcurve = driver_s
79     if fcurve == None:
80         fcurve = obj.data.shape_keys.keys[name].driver_add("value")
81         fcurve.driver.type = 'AVERAGE'
82         new = True
83
84     return fcurve, new
85
86
87 def metarig_template():
88     # generated by rigify.write_meta_rig
89     bpy.ops.object.mode_set(mode='EDIT')
90     obj = bpy.context.active_object
91     arm = obj.data
92     bone = arm.edit_bones.new('Bone')
93     bone.head[:] = 0.0000, 0.0000, 0.0000
94     bone.tail[:] = 0.0000, 0.0000, 1.0000
95     bone.roll = 0.0000
96     bone.use_connect = False
97
98     bpy.ops.object.mode_set(mode='OBJECT')
99     pbone = obj.pose.bones['Bone']
100     pbone['type'] = 'copy'
101
102
103 def metarig_definition(obj, orig_bone_name):
104     bone = obj.data.bones[orig_bone_name]
105     chain = []
106
107     try:
108         chain += [bone.parent.parent.name, bone.parent.name, bone.name]
109     except AttributeError:
110         raise RigifyError("'%s' rig type requires a chain of two parents (bone: %s)" % (RIG_TYPE, orig_bone_name))
111
112     chain += [child.name for child in bone.children_recursive_basename]
113
114     if len(chain) < 10:
115         raise RigifyError("'%s' rig type requires a chain of 8 bones (bone: %s)" % (RIG_TYPE, orig_bone_name))
116
117     return chain[:10]
118
119
120 def deform(obj, definitions, base_names, options):
121     bpy.ops.object.mode_set(mode='EDIT')
122
123     eb = obj.data.edit_bones
124     bb = obj.data.bones
125     pb = obj.pose.bones
126
127     jaw = definitions[1]
128
129     # Options
130     req_options = ["mesh"]
131     for option in req_options:
132         if option not in options:
133             raise RigifyError("'%s' rig type requires a '%s' option (bone: %s)" % (RIG_TYPE, option, base_names[definitions[0]]))
134
135     meshes = options["mesh"].replace(" ", "").split(",")
136
137     # Lip DEF
138     lip1 = copy_bone_simple(obj.data, definitions[2], "DEF-" + base_names[definitions[2]]).name
139     lip2 = copy_bone_simple(obj.data, definitions[3], "DEF-" + base_names[definitions[3]]).name
140     lip3 = copy_bone_simple(obj.data, definitions[4], "DEF-" + base_names[definitions[4]]).name
141     lip4 = copy_bone_simple(obj.data, definitions[5], "DEF-" + base_names[definitions[5]]).name
142     lip5 = copy_bone_simple(obj.data, definitions[6], "DEF-" + base_names[definitions[6]]).name
143     lip6 = copy_bone_simple(obj.data, definitions[7], "DEF-" + base_names[definitions[7]]).name
144     lip7 = copy_bone_simple(obj.data, definitions[8], "DEF-" + base_names[definitions[8]]).name
145     lip8 = copy_bone_simple(obj.data, definitions[9], "DEF-" + base_names[definitions[9]]).name
146
147     # Mouth corner spread bones (for driving corrective shape keys)
148     spread_l_1 = copy_bone_simple(obj.data, definitions[6], "MCH-" + base_names[definitions[6]] + ".spread_1").name
149     spread_l_2 = copy_bone_simple(obj.data, definitions[6], "MCH-" + base_names[definitions[6]] + ".spread_2").name
150     eb[spread_l_1].tail = eb[definitions[5]].head
151     eb[spread_l_2].tail = eb[definitions[5]].head
152     eb[spread_l_1].roll = 0
153     eb[spread_l_2].roll = 0
154     eb[spread_l_1].use_connect = False
155     eb[spread_l_2].use_connect = False
156     eb[spread_l_1].parent = eb[definitions[6]]
157     eb[spread_l_2].parent = eb[definitions[6]]
158
159     spread_r_1 = copy_bone_simple(obj.data, definitions[2], "MCH-" + base_names[definitions[2]] + ".spread_1").name
160     spread_r_2 = copy_bone_simple(obj.data, definitions[2], "MCH-" + base_names[definitions[2]] + ".spread_2").name
161     eb[spread_r_1].tail = eb[definitions[3]].head
162     eb[spread_r_2].tail = eb[definitions[3]].head
163     eb[spread_r_1].roll = 0
164     eb[spread_r_2].roll = 0
165     eb[spread_r_1].use_connect = False
166     eb[spread_r_2].use_connect = False
167     eb[spread_r_1].parent = eb[definitions[2]]
168     eb[spread_r_2].parent = eb[definitions[2]]
169
170
171
172     # Jaw open bones (for driving corrective shape keys)
173     jopen1 = copy_bone_simple(obj.data, jaw, "MCH-"+base_names[jaw]+".track1", parent=True).name
174     eb[jopen1].use_connect = False
175     eb[jopen1].head = eb[jaw].tail
176     eb[jopen1].tail = eb[jopen1].head + Vector((0, 0, eb[jaw].length/4))
177
178     jopen2 = copy_bone_simple(obj.data, jopen1, "MCH-"+base_names[jaw]+".track2").name
179     eb[jopen2].parent = eb[jaw]
180
181
182     bpy.ops.object.mode_set(mode='OBJECT')
183
184     # Constrain DEF bones to ORG bones
185     con = pb[lip1].constraints.new('COPY_TRANSFORMS')
186     con.target = obj
187     con.subtarget = definitions[2]
188
189     con = pb[lip2].constraints.new('COPY_TRANSFORMS')
190     con.target = obj
191     con.subtarget = definitions[3]
192
193     con = pb[lip3].constraints.new('COPY_TRANSFORMS')
194     con.target = obj
195     con.subtarget = definitions[4]
196
197     con = pb[lip4].constraints.new('COPY_TRANSFORMS')
198     con.target = obj
199     con.subtarget = definitions[5]
200
201     con = pb[lip5].constraints.new('COPY_TRANSFORMS')
202     con.target = obj
203     con.subtarget = definitions[6]
204
205     con = pb[lip6].constraints.new('COPY_TRANSFORMS')
206     con.target = obj
207     con.subtarget = definitions[7]
208
209     con = pb[lip7].constraints.new('COPY_TRANSFORMS')
210     con.target = obj
211     con.subtarget = definitions[8]
212
213     con = pb[lip8].constraints.new('COPY_TRANSFORMS')
214     con.target = obj
215     con.subtarget = definitions[9]
216
217     # Constraint mouth corner spread bones
218     con = pb[spread_l_1].constraints.new('DAMPED_TRACK')
219     con.target = obj
220     con.subtarget = lip4
221
222     con = pb[spread_l_2].constraints.new('COPY_TRANSFORMS')
223     con.target = obj
224     con.subtarget = spread_l_1
225
226     con = pb[spread_l_2].constraints.new('DAMPED_TRACK')
227     con.target = obj
228     con.subtarget = lip6
229
230     con = pb[spread_r_1].constraints.new('DAMPED_TRACK')
231     con.target = obj
232     con.subtarget = lip2
233
234     con = pb[spread_r_2].constraints.new('COPY_TRANSFORMS')
235     con.target = obj
236     con.subtarget = spread_r_1
237
238     con = pb[spread_r_2].constraints.new('DAMPED_TRACK')
239     con.target = obj
240     con.subtarget = lip8
241
242
243     # Corrective shape keys for the corners of the mouth.
244     bpy.ops.object.mode_set(mode='EDIT')
245
246     # Calculate the rotation difference between the bones
247     rotdiff_l = acos((eb[lip5].head - eb[lip4].head).normalize().dot((eb[lip5].head - eb[lip6].head).normalize()))
248     rotdiff_r = acos((eb[lip1].head - eb[lip2].head).normalize().dot((eb[lip1].head - eb[lip8].head).normalize()))
249
250     bpy.ops.object.mode_set(mode='OBJECT')
251
252
253     # Left side shape key
254     for mesh_name in meshes:
255         mesh_obj = bpy.data.objects[mesh_name]
256         shape_key_name = "COR-" + base_names[definitions[6]] + ".spread"
257
258         # Add/get the shape key
259         shape_key = addget_shape_key(mesh_obj, name=shape_key_name)
260
261         # Add/get the shape key driver
262         fcurve, is_new_driver = addget_shape_key_driver(mesh_obj, name=shape_key_name)
263         driver = fcurve.driver
264
265         # Get the variable, or create it if it doesn't already exist
266         var_name = base_names[definitions[6]]
267         if var_name in driver.variables:
268             var = driver.variables[var_name]
269         else:
270             var = driver.variables.new()
271             var.name = var_name
272
273         # Set up the variable
274         var.type = "ROTATION_DIFF"
275         var.targets[0].id = obj
276         var.targets[0].bone_target = spread_l_1
277         var.targets[1].id = obj
278         var.targets[1].bone_target = spread_l_2
279
280         # Set fcurve offset
281         if is_new_driver:
282             mod = fcurve.modifiers[0]
283             if rotdiff_l != pi:
284                 mod.coefficients[0] = -rotdiff_l / (pi-rotdiff_l)
285                 mod.coefficients[1] = 1 / (pi-rotdiff_l)
286
287     # Right side shape key
288     for mesh_name in meshes:
289         mesh_obj = bpy.data.objects[mesh_name]
290         shape_key_name = "COR-" + base_names[definitions[2]] + ".spread"
291
292         # Add/get the shape key
293         shape_key = addget_shape_key(mesh_obj, name=shape_key_name)
294
295         # Add/get the shape key driver
296         fcurve, is_new_driver = addget_shape_key_driver(mesh_obj, name=shape_key_name)
297         driver = fcurve.driver
298
299         # Get the variable, or create it if it doesn't already exist
300         var_name = base_names[definitions[2]]
301         if var_name in driver.variables:
302             var = driver.variables[var_name]
303         else:
304             var = driver.variables.new()
305             var.name = var_name
306
307         # Set up the variable
308         var.type = "ROTATION_DIFF"
309         var.targets[0].id = obj
310         var.targets[0].bone_target = spread_r_1
311         var.targets[1].id = obj
312         var.targets[1].bone_target = spread_r_2
313
314         # Set fcurve offset
315         if is_new_driver:
316             mod = fcurve.modifiers[0]
317             if rotdiff_r != pi:
318                 mod.coefficients[0] = -rotdiff_r / (pi-rotdiff_r)
319                 mod.coefficients[1] = 1 / (pi-rotdiff_r)
320
321     # Jaw open corrective shape key
322     for mesh_name in meshes:
323         mesh_obj = bpy.data.objects[mesh_name]
324         shape_key_name = "COR-" + base_names[definitions[4]] + ".jaw_open"
325
326         # Add/get the shape key
327         shape_key = addget_shape_key(mesh_obj, name=shape_key_name)
328
329         # Add/get the shape key driver
330         fcurve, is_new_driver = addget_shape_key_driver(mesh_obj, name=shape_key_name)
331         driver = fcurve.driver
332
333         # Get the variable, or create it if it doesn't already exist
334         var_name = base_names[definitions[4]]
335         if var_name in driver.variables:
336             var = driver.variables[var_name]
337         else:
338             var = driver.variables.new()
339             var.name = var_name
340
341         # Set up the variable
342         var.type = "LOC_DIFF"
343         var.targets[0].id = obj
344         var.targets[0].bone_target = jopen1
345         var.targets[1].id = obj
346         var.targets[1].bone_target = jopen2
347
348         # Set fcurve offset
349         if is_new_driver:
350             mod = fcurve.modifiers[0]
351             mod.coefficients[0] = 0.0
352             mod.coefficients[1] = 1.0 / bb[jaw].length
353
354     return (None,)
355
356
357
358
359 def control(obj, definitions, base_names, options):
360     bpy.ops.object.mode_set(mode='EDIT')
361
362     eb = obj.data.edit_bones
363     bb = obj.data.bones
364     pb = obj.pose.bones
365
366     head_e = eb[definitions[0]]
367     jaw_e = eb[definitions[1]]
368     jaw = definitions[1]
369
370     # Head lips
371     hlip1 = copy_bone_simple(obj.data, definitions[2], "MCH-"+base_names[definitions[2]]+".head").name
372     hlip2 = copy_bone_simple(obj.data, definitions[3], "MCH-"+base_names[definitions[3]]+".head").name
373     hlip3 = copy_bone_simple(obj.data, definitions[4], "MCH-"+base_names[definitions[4]]+".head").name
374     hlip4 = copy_bone_simple(obj.data, definitions[5], "MCH-"+base_names[definitions[5]]+".head").name
375     hlip5 = copy_bone_simple(obj.data, definitions[6], "MCH-"+base_names[definitions[6]]+".head").name
376     hlip6 = copy_bone_simple(obj.data, definitions[7], "MCH-"+base_names[definitions[7]]+".head").name
377     hlip7 = copy_bone_simple(obj.data, definitions[8], "MCH-"+base_names[definitions[8]]+".head").name
378     hlip8 = copy_bone_simple(obj.data, definitions[9], "MCH-"+base_names[definitions[9]]+".head").name
379
380     eb[hlip1].parent = head_e
381     eb[hlip2].parent = head_e
382     eb[hlip3].parent = head_e
383     eb[hlip4].parent = head_e
384     eb[hlip5].parent = head_e
385     eb[hlip6].parent = head_e
386     eb[hlip7].parent = head_e
387     eb[hlip8].parent = head_e
388
389     # Jaw lips
390     jlip1 = copy_bone_simple(obj.data, definitions[2], "MCH-"+base_names[definitions[2]]+".jaw").name
391     jlip2 = copy_bone_simple(obj.data, definitions[3], "MCH-"+base_names[definitions[3]]+".jaw").name
392     jlip3 = copy_bone_simple(obj.data, definitions[4], "MCH-"+base_names[definitions[4]]+".jaw").name
393     jlip4 = copy_bone_simple(obj.data, definitions[5], "MCH-"+base_names[definitions[5]]+".jaw").name
394     jlip5 = copy_bone_simple(obj.data, definitions[6], "MCH-"+base_names[definitions[6]]+".jaw").name
395     jlip6 = copy_bone_simple(obj.data, definitions[7], "MCH-"+base_names[definitions[7]]+".jaw").name
396     jlip7 = copy_bone_simple(obj.data, definitions[8], "MCH-"+base_names[definitions[8]]+".jaw").name
397     jlip8 = copy_bone_simple(obj.data, definitions[9], "MCH-"+base_names[definitions[9]]+".jaw").name
398
399     eb[jlip1].parent = jaw_e
400     eb[jlip2].parent = jaw_e
401     eb[jlip3].parent = jaw_e
402     eb[jlip4].parent = jaw_e
403     eb[jlip5].parent = jaw_e
404     eb[jlip6].parent = jaw_e
405     eb[jlip7].parent = jaw_e
406     eb[jlip8].parent = jaw_e
407
408     # Control lips
409     lip1 = copy_bone_simple(obj.data, definitions[2], base_names[definitions[2]]).name
410     lip2 = copy_bone_simple(obj.data, definitions[3], base_names[definitions[3]]).name
411     lip3 = copy_bone_simple(obj.data, definitions[4], base_names[definitions[4]]).name
412     lip4 = copy_bone_simple(obj.data, definitions[5], base_names[definitions[5]]).name
413     lip5 = copy_bone_simple(obj.data, definitions[6], base_names[definitions[6]]).name
414     lip6 = copy_bone_simple(obj.data, definitions[7], base_names[definitions[7]]).name
415     lip7 = copy_bone_simple(obj.data, definitions[8], base_names[definitions[8]]).name
416     lip8 = copy_bone_simple(obj.data, definitions[9], base_names[definitions[9]]).name
417
418     eb[lip1].parent = eb[hlip1]
419     eb[lip2].parent = eb[hlip2]
420     eb[lip3].parent = eb[hlip3]
421     eb[lip4].parent = eb[hlip4]
422     eb[lip5].parent = eb[hlip5]
423     eb[lip6].parent = eb[hlip6]
424     eb[lip7].parent = eb[hlip7]
425     eb[lip8].parent = eb[hlip8]
426
427     # Jaw open tracker
428     jopent = copy_bone_simple(obj.data, jaw_e.name, "MCH-"+base_names[jaw_e.name]+".track", parent=True).name
429     eb[jopent].use_connect = False
430     eb[jopent].tail = jaw_e.tail + Vector((0.0, 0.0, jaw_e.length))
431     eb[jopent].head = jaw_e.tail
432
433     bpy.ops.object.mode_set(mode='OBJECT')
434
435     # Add mouth open action if it doesn't already exist
436     action_name = "mouth_open"
437     if action_name in bpy.data.actions:
438         open_action = bpy.data.actions[action_name]
439     else:
440         open_action = add_action(name=action_name)
441
442     # Add close property (useful when making the animation in the action)
443     prop_name = "open_action"
444     prop = rna_idprop_ui_prop_get(pb[lip1], prop_name, create=True)
445     pb[lip1][prop_name] = 1.0
446     prop["soft_min"] = 0.0
447     prop["soft_max"] = 1.0
448     prop["min"] = 0.0
449     prop["max"] = 1.0
450
451     open_driver_path = pb[lip1].path_from_id() + '["open_action"]'
452
453
454     # Constraints
455
456     # Jaw open tracker stretches to jaw tip
457     con = pb[jopent].constraints.new('STRETCH_TO')
458     con.target = obj
459     con.subtarget = jaw
460     con.head_tail = 1.0
461     con.rest_length = bb[jopent].length
462     con.volume = 'NO_VOLUME'
463
464     # Head lips to jaw lips
465     influence = [0.02, 0.1, 0.35, 0.25, 0.0]
466
467     con = pb[hlip1].constraints.new('COPY_TRANSFORMS')
468     con.target = obj
469     con.subtarget = jlip1
470     con.influence = influence[2]
471
472     con = pb[hlip2].constraints.new('COPY_TRANSFORMS')
473     con.target = obj
474     con.subtarget = jlip2
475     con.influence = influence[1]
476
477     con = pb[hlip3].constraints.new('COPY_TRANSFORMS')
478     con.target = obj
479     con.subtarget = jlip3
480     con.influence = influence[0]
481
482     con = pb[hlip4].constraints.new('COPY_TRANSFORMS')
483     con.target = obj
484     con.subtarget = jlip4
485     con.influence = influence[1]
486
487     con = pb[hlip5].constraints.new('COPY_TRANSFORMS')
488     con.target = obj
489     con.subtarget = jlip5
490     con.influence = influence[2]
491
492     con = pb[hlip6].constraints.new('COPY_TRANSFORMS')
493     con.target = obj
494     con.subtarget = jlip6
495     con.influence = 1.0 - influence[3]
496
497     con = pb[hlip7].constraints.new('COPY_TRANSFORMS')
498     con.target = obj
499     con.subtarget = jlip7
500     con.influence = 1.0 - influence[4]
501
502     con = pb[hlip8].constraints.new('COPY_TRANSFORMS')
503     con.target = obj
504     con.subtarget = jlip8
505     con.influence = 1.0 - influence[3]
506
507     # ORG bones to lips
508     con = pb[definitions[2]].constraints.new('COPY_TRANSFORMS')
509     con.target = obj
510     con.subtarget = lip1
511
512     con = pb[definitions[3]].constraints.new('COPY_TRANSFORMS')
513     con.target = obj
514     con.subtarget = lip2
515
516     con = pb[definitions[4]].constraints.new('COPY_TRANSFORMS')
517     con.target = obj
518     con.subtarget = lip3
519
520     con = pb[definitions[5]].constraints.new('COPY_TRANSFORMS')
521     con.target = obj
522     con.subtarget = lip4
523
524     con = pb[definitions[6]].constraints.new('COPY_TRANSFORMS')
525     con.target = obj
526     con.subtarget = lip5
527
528     con = pb[definitions[7]].constraints.new('COPY_TRANSFORMS')
529     con.target = obj
530     con.subtarget = lip6
531
532     con = pb[definitions[8]].constraints.new('COPY_TRANSFORMS')
533     con.target = obj
534     con.subtarget = lip7
535
536     con = pb[definitions[9]].constraints.new('COPY_TRANSFORMS')
537     con.target = obj
538     con.subtarget = lip8
539
540     # Action constraints for open mouth
541     con = pb[lip1].constraints.new('ACTION')
542     con.target = obj
543     con.subtarget = jopent
544     con.action = open_action
545     con.transform_channel = 'SCALE_Y'
546     con.frame_start = 0
547     con.frame_end = 60
548     con.min = 0.0
549     con.max = 1.0
550     con.target_space = 'LOCAL'
551     fcurve = con.driver_add("influence")
552     driver = fcurve.driver
553     driver.type = 'AVERAGE'
554     var = driver.variables.new()
555     var.targets[0].id_type = 'OBJECT'
556     var.targets[0].id = obj
557     var.targets[0].data_path = open_driver_path
558
559     con = pb[lip2].constraints.new('ACTION')
560     con.target = obj
561     con.subtarget = jopent
562     con.action = open_action
563     con.transform_channel = 'SCALE_Y'
564     con.frame_start = 0
565     con.frame_end = 60
566     con.min = 0.0
567     con.max = 1.0
568     con.target_space = 'LOCAL'
569     fcurve = con.driver_add("influence")
570     driver = fcurve.driver
571     driver.type = 'AVERAGE'
572     var = driver.variables.new()
573     var.targets[0].id_type = 'OBJECT'
574     var.targets[0].id = obj
575     var.targets[0].data_path = open_driver_path
576
577     con = pb[lip3].constraints.new('ACTION')
578     con.target = obj
579     con.subtarget = jopent
580     con.action = open_action
581     con.transform_channel = 'SCALE_Y'
582     con.frame_start = 0
583     con.frame_end = 60
584     con.min = 0.0
585     con.max = 1.0
586     con.target_space = 'LOCAL'
587     fcurve = con.driver_add("influence")
588     driver = fcurve.driver
589     driver.type = 'AVERAGE'
590     var = driver.variables.new()
591     var.targets[0].id_type = 'OBJECT'
592     var.targets[0].id = obj
593     var.targets[0].data_path = open_driver_path
594
595     con = pb[lip4].constraints.new('ACTION')
596     con.target = obj
597     con.subtarget = jopent
598     con.action = open_action
599     con.transform_channel = 'SCALE_Y'
600     con.frame_start = 0
601     con.frame_end = 60
602     con.min = 0.0
603     con.max = 1.0
604     con.target_space = 'LOCAL'
605     fcurve = con.driver_add("influence")
606     driver = fcurve.driver
607     driver.type = 'AVERAGE'
608     var = driver.variables.new()
609     var.targets[0].id_type = 'OBJECT'
610     var.targets[0].id = obj
611     var.targets[0].data_path = open_driver_path
612
613     con = pb[lip5].constraints.new('ACTION')
614     con.target = obj
615     con.subtarget = jopent
616     con.action = open_action
617     con.transform_channel = 'SCALE_Y'
618     con.frame_start = 0
619     con.frame_end = 60
620     con.min = 0.0
621     con.max = 1.0
622     con.target_space = 'LOCAL'
623     fcurve = con.driver_add("influence")
624     driver = fcurve.driver
625     driver.type = 'AVERAGE'
626     var = driver.variables.new()
627     var.targets[0].id_type = 'OBJECT'
628     var.targets[0].id = obj
629     var.targets[0].data_path = open_driver_path
630
631     con = pb[lip6].constraints.new('ACTION')
632     con.target = obj
633     con.subtarget = jopent
634     con.action = open_action
635     con.transform_channel = 'SCALE_Y'
636     con.frame_start = 0
637     con.frame_end = 60
638     con.min = 0.0
639     con.max = 1.0
640     con.target_space = 'LOCAL'
641     fcurve = con.driver_add("influence")
642     driver = fcurve.driver
643     driver.type = 'AVERAGE'
644     var = driver.variables.new()
645     var.targets[0].id_type = 'OBJECT'
646     var.targets[0].id = obj
647     var.targets[0].data_path = open_driver_path
648
649     con = pb[lip7].constraints.new('ACTION')
650     con.target = obj
651     con.subtarget = jopent
652     con.action = open_action
653     con.transform_channel = 'SCALE_Y'
654     con.frame_start = 0
655     con.frame_end = 60
656     con.min = 0.0
657     con.max = 1.0
658     con.target_space = 'LOCAL'
659     fcurve = con.driver_add("influence")
660     driver = fcurve.driver
661     driver.type = 'AVERAGE'
662     var = driver.variables.new()
663     var.targets[0].id_type = 'OBJECT'
664     var.targets[0].id = obj
665     var.targets[0].data_path = open_driver_path
666
667     con = pb[lip8].constraints.new('ACTION')
668     con.target = obj
669     con.subtarget = jopent
670     con.action = open_action
671     con.transform_channel = 'SCALE_Y'
672     con.frame_start = 0
673     con.frame_end = 60
674     con.min = 0.0
675     con.max = 1.0
676     con.target_space = 'LOCAL'
677     fcurve = con.driver_add("influence")
678     driver = fcurve.driver
679     driver.type = 'AVERAGE'
680     var = driver.variables.new()
681     var.targets[0].id_type = 'OBJECT'
682     var.targets[0].id = obj
683     var.targets[0].data_path = open_driver_path
684
685
686     # Set layers
687     layer = list(bb[definitions[2]].layers)
688     bb[lip1].layers = layer
689     bb[lip2].layers = layer
690     bb[lip3].layers = layer
691     bb[lip4].layers = layer
692     bb[lip5].layers = layer
693     bb[lip6].layers = layer
694     bb[lip7].layers = layer
695     bb[lip8].layers = layer
696
697
698     return (None,)
699
700
701
702
703 def main(obj, bone_definition, base_names, options):
704     # Create control rig
705     control(obj, bone_definition, base_names, options)
706     # Create deform rig
707     deform(obj, bone_definition, base_names, options)
708
709     return (None,)
710
711
712
713
714 def make_lip_stretch_bone(obj, name, bone1, bone2, roll_alpha):
715     eb = obj.data.edit_bones
716     pb = obj.pose.bones
717
718     # Create the bone, pointing from bone1 to bone2
719     bone_e = copy_bone_simple(obj.data, bone1, name, parent=True)
720     bone_e.use_connect = False
721     bone_e.tail = eb[bone2].head
722     bone = bone_e.name
723
724     # Align the bone roll with the average direction of bone1 and bone2
725     vec = bone_e.y_axis.cross(((1.0-roll_alpha)*eb[bone1].y_axis) + (roll_alpha*eb[bone2].y_axis)).normalize()
726
727     ang = acos(vec * bone_e.x_axis)
728
729     bone_e.roll += ang
730     c1 = vec * bone_e.x_axis
731     bone_e.roll -= (ang*2)
732     c2 = vec * bone_e.x_axis
733
734     if c1 > c2:
735         bone_e.roll += (ang*2)
736
737     bpy.ops.object.mode_set(mode='OBJECT')
738     bone_p = pb[bone]
739
740     # Constrains
741     con = bone_p.constraints.new('COPY_LOCATION')
742     con.target = obj
743     con.subtarget = bone1
744
745     con = bone_p.constraints.new('DAMPED_TRACK')
746     con.target = obj
747     con.subtarget = bone2
748
749     con = bone_p.constraints.new('STRETCH_TO')
750     con.target = obj
751     con.subtarget = bone2
752     con.volume = 'NO_VOLUME'
753
754     bpy.ops.object.mode_set(mode='EDIT')
755
756     return bone