b1889d7c36fdebd0852f62e2eb2c29634e9b850e
[blender-staging.git] / release / scripts / modules / rigify / eye_balls.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 mathutils import Vector
24 from rigify import RigifyError
25 from rigify_utils import copy_bone_simple
26
27 #METARIG_NAMES = ("cpy",)
28 RIG_TYPE = "eye_balls"
29
30 def addget_shape_key(obj, name="Key"):
31     """ Fetches a shape key, or creates it if it doesn't exist
32     """
33     # Create a shapekey set if it doesn't already exist
34     if obj.data.shape_keys is None:
35         shape = obj.add_shape_key(name="Basis", from_mix=False)
36         obj.active_shape_key_index = 0
37
38     # Get the shapekey, or create it if it doesn't already exist
39     if name in obj.data.shape_keys.keys:
40         shape_key = obj.data.shape_keys.keys[name]
41     else:
42         shape_key = obj.add_shape_key(name=name, from_mix=False)
43
44     return shape_key
45
46
47 def addget_shape_key_driver(obj, name="Key"):
48     """ Fetches the driver for the shape key, or creates it if it doesn't
49         already exist.
50     """
51     driver_path = 'keys["' + name + '"].value'
52     fcurve = None
53     driver = None
54     new = False
55     if obj.data.shape_keys.animation_data is not None:
56         for driver_s in obj.data.shape_keys.animation_data.drivers:
57             if driver_s.data_path == driver_path:
58                 fcurve = driver_s
59     if fcurve == None:
60         fcurve = obj.data.shape_keys.keys[name].driver_add("value")
61         fcurve.driver.type = 'AVERAGE'
62         new = True
63
64     return fcurve, new
65    
66     
67 def create_shape_and_driver(obj, bone, meshes, shape_name, var_name, var_path, expression):
68     """ Creates/gets a shape key and sets up a driver for it.
69
70         obj = armature object
71         bone = driving bone name
72         meshes = list of meshes to create the shapekey/driver on
73         shape_name = name of the shape key
74         var_name = name of the driving variable
75         var_path = path to the property on the bone to drive with
76         expression = python expression for the driver
77     """
78     pb = obj.pose.bones
79     bpy.ops.object.mode_set(mode='OBJECT')
80
81     for mesh_name in meshes:
82         mesh_obj = bpy.data.objects[mesh_name]
83
84         # Add/get the shape key
85         shape = addget_shape_key(mesh_obj, name=shape_name)
86
87         # Add/get the shape key driver
88         fcurve, a = addget_shape_key_driver(mesh_obj, name=shape_name)
89
90         # Set up the driver
91         driver = fcurve.driver
92         driver.type = 'SCRIPTED'
93         driver.expression = expression
94
95         # Get the variable, or create it if it doesn't already exist
96         if var_name in driver.variables:
97             var = driver.variables[var_name]
98         else:
99             var = driver.variables.new()
100             var.name = var_name
101
102         # Set up the variable
103         var.type = "SINGLE_PROP"
104         var.targets[0].id_type = 'OBJECT'
105         var.targets[0].id = obj
106         var.targets[0].data_path = 'pose.bones["' + bone + '"]' + var_path
107
108
109 def mark_actions():
110     for action in bpy.data.actions:
111         action.tag = True
112
113 def get_unmarked_action():
114     for action in bpy.data.actions:
115         if action.tag != True:
116             return action
117     return None
118
119 def add_action(name=None):
120     mark_actions()
121     bpy.ops.action.new()
122     action = get_unmarked_action()
123     if name is not None:
124         action.name = name
125     return action
126
127
128 def metarig_template():
129     # generated by rigify.write_meta_rig
130     bpy.ops.object.mode_set(mode='EDIT')
131     obj = bpy.context.active_object
132     arm = obj.data
133     bone = arm.edit_bones.new('Bone')
134     bone.head[:] = 0.0000, 0.0000, 0.0000
135     bone.tail[:] = 0.0000, 0.0000, 1.0000
136     bone.roll = 0.0000
137     bone.use_connect = False
138
139     bpy.ops.object.mode_set(mode='OBJECT')
140     pbone = obj.pose.bones['Bone']
141     pbone['type'] = 'copy'
142
143
144 def metarig_definition(obj, orig_bone_name):
145     bone = obj.data.bones[orig_bone_name]
146     chain = []
147
148     try:
149         chain += [bone.parent.name, bone.name]
150     except AttributeError:
151         raise RigifyError("'%s' rig type requires a parent (bone: %s)" % (RIG_TYPE, orig_bone_name))
152
153     return chain
154
155
156 def deform(obj, definitions, base_names, options):
157     bpy.ops.object.mode_set(mode='EDIT')
158
159     eb = obj.data.edit_bones
160     pb = obj.pose.bones
161
162     # Get list of eyes
163     if "eyes" in options:
164         eye_base_names = options["eyes"].replace(" ", "").split(",")
165     else:
166         eye_base_names = []
167
168     # Get their ORG- names
169     eyes = []
170     for name in eye_base_names:
171         eyes += ["ORG-"+name]
172
173     # Duplicate the eyes to make deformation bones
174     def_eyes = [] # def/org pairs
175     for eye in eyes:
176         def_eyes += [(copy_bone_simple(obj.data, eye, "DEF-"+base_names[eye], parent=True).name, eye)]
177
178
179     bpy.ops.object.mode_set(mode='OBJECT')
180
181     # Constraints
182     for eye in def_eyes:
183         con = pb[eye[0]].constraints.new('COPY_TRANSFORMS')
184         con.target = obj
185         con.subtarget = eye[1]
186
187     return (None,)
188
189
190
191
192 def control(obj, definitions, base_names, options):
193     bpy.ops.object.mode_set(mode='EDIT')
194
195     eb = obj.data.edit_bones
196     bb = obj.data.bones
197     pb = obj.pose.bones
198
199     head = definitions[0]
200     eye_target = definitions[1]
201
202     # Get list of pupil mesh objects
203     if "mesh" in options:
204         pupil_meshes = options["mesh"].replace(" ", "").split(",")
205     else:
206         pupil_meshes = []
207
208     # Get list of eyes
209     if "eyes" in options:
210         eye_base_names = options["eyes"].replace(" ", "").split(",")
211     else:
212         eye_base_names = []
213
214     # Get their ORG- names
215     eyes = []
216     for name in eye_base_names:
217         eyes += ["ORG-"+name]
218
219     # Get the average position of the eyes
220     center = Vector((0, 0, 0))
221     for eye in eyes:
222         center += eb[eye].head
223     if len(eyes) != 0:
224         center /= len(eyes)
225
226     # Get the average length of the eyes
227     length = 0.0
228     for eye in eyes:
229         length += eb[eye].length
230     if len(eyes) == 0:
231         length = 1.0
232     else:
233         length /= len(eyes)
234
235
236     # Make the mind's eye
237     minds_eye = copy_bone_simple(obj.data, eye_target, "MCH-"+base_names[eye_target]+".mind", parent=True).name
238     eb[minds_eye].head = center
239     eb[minds_eye].tail = eb[eye_target].head
240     eb[minds_eye].roll = 0.0
241     eb[minds_eye].length = length
242
243     # Create org/copy/control eye sets
244     eye_sets = []
245     for eye in eyes:
246         copy = copy_bone_simple(obj.data, minds_eye, "MCH-"+base_names[eye]+".cpy", parent=True).name
247         eb[copy].translate(eb[eye].head - eb[copy].head)
248         eb[copy].parent = eb[eye].parent
249
250         control = copy_bone_simple(obj.data, eye, base_names[eye], parent=True).name
251         eb[control].parent = eb[copy]
252
253         eye_sets += [(eye, copy, control)]
254
255     # Bones for parent/free switch for eye target
256     target_ctrl = copy_bone_simple(obj.data, eye_target, base_names[eye_target], parent=True).name
257     parent = copy_bone_simple(obj.data, head, "MCH-eye_target_parent", parent=False).name
258
259     eb[target_ctrl].parent = eb[parent]
260
261
262
263
264     bpy.ops.object.mode_set(mode='OBJECT')
265
266     # Axis locks
267     pb[target_ctrl].lock_scale = False, True, True
268
269     # Add eye_spread action if it doesn't already exist
270     action_name = "eye_spread"
271     if action_name in bpy.data.actions:
272         spread_action = bpy.data.actions[action_name]
273     else:
274         spread_action = add_action(name=action_name)
275
276     # Add free property
277     prop_name = "free"
278     prop = rna_idprop_ui_prop_get(pb[target_ctrl], prop_name, create=True)
279     pb[target_ctrl][prop_name] = 0.0
280     prop["soft_min"] = 0.0
281     prop["soft_max"] = 1.0
282     prop["min"] = 0.0
283     prop["max"] = 1.0
284
285     free_driver_path = pb[target_ctrl].path_from_id() + '["free"]'
286
287     # Constraints
288     # Mind's eye tracks eye target control
289     con = pb[minds_eye].constraints.new('DAMPED_TRACK')
290     con.target = obj
291     con.subtarget = target_ctrl
292
293     # Parent copies transforms of head
294     con = pb[parent].constraints.new('COPY_TRANSFORMS')
295     con.target = obj
296     con.subtarget = head
297
298     fcurve = con.driver_add("influence")
299     driver = fcurve.driver
300     driver.type = 'AVERAGE'
301     mod = fcurve.modifiers[0]
302     mod.coefficients[0] = 1.0
303     mod.coefficients[1] = -1.0
304
305     var = driver.variables.new()
306     var.name = "free"
307     var.targets[0].id_type = 'OBJECT'
308     var.targets[0].id = obj
309     var.targets[0].data_path = free_driver_path
310
311     # Eye set's constraints
312     for eye in eye_sets:
313         # Org copies transforms of control
314         con = pb[eye[0]].constraints.new('COPY_TRANSFORMS')
315         con.target = obj
316         con.subtarget = eye[2]
317
318         # Copy copies rotation of mind's eye
319         con = pb[eye[1]].constraints.new('COPY_ROTATION')
320         con.target = obj
321         con.subtarget = minds_eye
322
323         # Control gets action constraint for eye spread
324         con = pb[eye[2]].constraints.new('ACTION')
325         con.target = obj
326         con.subtarget = target_ctrl
327         con.action = spread_action
328         con.transform_channel = 'SCALE_X'
329         con.frame_start = -20
330         con.frame_end = 20
331         con.minimum = 0.0
332         con.maximum = 2.0
333         con.target_space = 'LOCAL'
334     
335     
336     # Get/create the shape keys and drivers for pupil dilation
337     shape_names = ["PUPILS-dilate_wide", "PUPILS-dilate_narrow"]
338     slider_name = "pupil_dilate"
339     
340     # Set up the custom property on the bone
341     prop = rna_idprop_ui_prop_get(pb[target_ctrl], slider_name, create=True)
342     pb[target_ctrl][slider_name] = 0.0
343     prop["min"] = 0.0
344     prop["max"] = 1.0
345     prop["soft_min"] = 0.0
346     prop["soft_max"] = 1.0
347     if len(shape_names) > 1:
348         prop["min"] = -1.0
349         prop["soft_min"] = -1.0
350
351     # Add the shape drivers
352     # Positive
353     if shape_names[0] != "":
354         # Set up the variables for creating the shape key driver
355         shape_name = shape_names[0]
356         var_name = slider_name.replace(".", "_").replace("-", "_")
357         var_path = '["' + slider_name + '"]'
358         if slider_name + "_fac" in options:
359             fac = options[slider_name + "_fac"]
360         else:
361             fac = 1.0
362         expression = var_name + " * " + str(fac)
363         # Create the shape key driver
364         create_shape_and_driver(obj, target_ctrl, pupil_meshes, shape_name, var_name, var_path, expression)
365     # Negative
366     if shape_names[0] != "" and len(shape_names) > 1:
367         # Set up the variables for creating the shape key driver
368         shape_name = shape_names[1]
369         var_name = slider_name.replace(".", "_").replace("-", "_")
370         var_path = '["' + slider_name + '"]'
371         if slider_name + "_fac" in options:
372             fac = options[slider_name + "_fac"]
373         else:
374             fac = 1.0
375         expression = var_name + " * " + str(fac) + " * -1"
376         # Create the shape key driver
377         create_shape_and_driver(obj, target_ctrl, pupil_meshes, shape_name, var_name, var_path, expression)
378
379
380
381     # Set layers
382     #layer = list(bb[definitions[2]].layers)
383     #bb[lid1].layers = layer
384     #bb[lid2].layers = layer
385     #bb[lid3].layers = layer
386     #bb[lid4].layers = layer
387     #bb[lid5].layers = layer
388     #bb[lid6].layers = layer
389     #bb[lid7].layers = layer
390     #bb[lid8].layers = layer
391
392
393     return (None,)
394
395
396
397
398 def main(obj, bone_definition, base_names, options):
399     # Create control rig
400     control(obj, bone_definition, base_names, options)
401     # Create deform rig
402     deform(obj, bone_definition, base_names, options)
403
404     return (None,)
405