edits to the bone copy metarig type from Cessen, pointcache warning fix
[blender.git] / release / scripts / modules / rigify / neck_flex.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 # <pep8 compliant>
20
21 import bpy
22 from rigify import RigifyError, get_layer_dict
23 from rigify_utils import bone_class_instance, copy_bone_simple
24 from rna_prop_ui import rna_idprop_ui_prop_get
25
26 # not used, defined for completeness
27 METARIG_NAMES = ("body", "head")
28
29
30 def metarig_template():
31     # generated by rigify.write_meta_rig
32     bpy.ops.object.mode_set(mode='EDIT')
33     obj = bpy.context.active_object
34     arm = obj.data
35     bone = arm.edit_bones.new('body')
36     bone.head[:] = -0.0000, -0.2771, -1.3345
37     bone.tail[:] = -0.0000, -0.1708, -0.1984
38     bone.roll = 0.0000
39     bone.connected = False
40     bone = arm.edit_bones.new('head')
41     bone.head[:] = -0.0000, -0.1708, -0.1984
42     bone.tail[:] = 0.0000, 0.7292, 1.3604
43     bone.roll = 0.0000
44     bone.connected = True
45     bone.parent = arm.edit_bones['body']
46     bone = arm.edit_bones.new('neck.01')
47     bone.head[:] = 0.0000, -0.1708, -0.1984
48     bone.tail[:] = -0.0000, -0.0994, 0.1470
49     bone.roll = -0.0000
50     bone.connected = False
51     bone.parent = arm.edit_bones['head']
52     bone = arm.edit_bones.new('neck.02')
53     bone.head[:] = -0.0000, -0.0994, 0.1470
54     bone.tail[:] = 0.0000, -0.2428, 0.5162
55     bone.roll = -0.0000
56     bone.connected = True
57     bone.parent = arm.edit_bones['neck.01']
58     bone = arm.edit_bones.new('neck.03')
59     bone.head[:] = 0.0000, -0.2428, 0.5162
60     bone.tail[:] = 0.0000, -0.4190, 0.8722
61     bone.roll = -0.0000
62     bone.connected = True
63     bone.parent = arm.edit_bones['neck.02']
64     bone = arm.edit_bones.new('neck.04')
65     bone.head[:] = 0.0000, -0.4190, 0.8722
66     bone.tail[:] = 0.0000, -0.5111, 1.1956
67     bone.roll = 0.0000
68     bone.connected = True
69     bone.parent = arm.edit_bones['neck.03']
70     bone = arm.edit_bones.new('neck.05')
71     bone.head[:] = 0.0000, -0.5111, 1.1956
72     bone.tail[:] = 0.0000, -0.5391, 1.6081
73     bone.roll = 0.0000
74     bone.connected = True
75     bone.parent = arm.edit_bones['neck.04']
76
77     bpy.ops.object.mode_set(mode='OBJECT')
78     pbone = obj.pose.bones['head']
79     pbone['type'] = 'neck_flex'
80
81
82 def metarig_definition(obj, orig_bone_name):
83     '''
84     The bone given is the head, its parent is the body,
85     # its only child the first of a chain with matching basenames.
86     eg.
87         body -> head -> neck_01 -> neck_02 -> neck_03.... etc
88     '''
89     arm = obj.data
90     head = arm.bones[orig_bone_name]
91     body = head.parent
92
93     children = head.children
94     if len(children) != 1:
95         raise RigifyError("expected the head bone '%s' to have only 1 child." % orig_bone_name)
96
97     child = children[0]
98     bone_definition = [body.name, head.name, child.name]
99     bone_definition.extend([child.name for child in child.children_recursive_basename])
100     return bone_definition
101
102
103 def main(obj, bone_definition, base_names, options):
104     from Mathutils import Vector
105
106     arm = obj.data
107
108     # Initialize container classes for convenience
109     mt = bone_class_instance(obj, ["body", "head"]) # meta
110     mt.body = bone_definition[0]
111     mt.head = bone_definition[1]
112     mt.update()
113
114     neck_chain = bone_definition[2:]
115
116     mt_chain = bone_class_instance(obj, [("neck_%.2d" % (i + 1)) for i in range(len(neck_chain))]) # 99 bones enough eh?
117     for i, attr in enumerate(mt_chain.attr_names):
118         setattr(mt_chain, attr, neck_chain[i])
119     mt_chain.update()
120
121     neck_chain_basename = base_names[mt_chain.neck_01_e.name].split(".")[0]
122     neck_chain_segment_length = mt_chain.neck_01_e.length
123
124     ex = bone_class_instance(obj, ["head", "head_hinge", "neck_socket", "head_ctrl"]) # hinge & extras
125
126     # Add the head hinge at the bodys location, becomes the parent of the original head
127
128     # apply everything to this copy of the chain
129     ex_chain = mt_chain.copy(base_names=base_names)
130     ex_chain.neck_01_e.parent = mt_chain.neck_01_e.parent
131
132
133     # Copy the head bone and offset
134     ex.head_e = copy_bone_simple(arm, mt.head, "MCH_%s" % base_names[mt.head], parent=True)
135     ex.head_e.connected = False
136     ex.head = ex.head_e.name
137     # offset
138     head_length = ex.head_e.length
139     ex.head_e.head.y += head_length / 2.0
140     ex.head_e.tail.y += head_length / 2.0
141
142     # Yes, use the body bone but call it a head hinge
143     ex.head_hinge_e = copy_bone_simple(arm, mt.body, "MCH_%s_hinge" % base_names[mt.head], parent=False)
144     ex.head_hinge_e.connected = False
145     ex.head_hinge = ex.head_hinge_e.name
146     ex.head_hinge_e.head.y += head_length / 4.0
147     ex.head_hinge_e.tail.y += head_length / 4.0
148
149     # Insert the neck socket, the head copys this loation
150     ex.neck_socket_e = arm.edit_bones.new("MCH-%s_socked" % neck_chain_basename)
151     ex.neck_socket = ex.neck_socket_e.name
152     ex.neck_socket_e.connected = False
153     ex.neck_socket_e.parent = mt.body_e
154     ex.neck_socket_e.head = mt.head_e.head
155     ex.neck_socket_e.tail = mt.head_e.head - Vector(0.0, neck_chain_segment_length / 2.0, 0.0)
156     ex.neck_socket_e.roll = 0.0
157
158
159     # copy of the head for controling
160     ex.head_ctrl_e = copy_bone_simple(arm, mt.head, base_names[mt.head])
161     ex.head_ctrl = ex.head_ctrl_e.name
162     ex.head_ctrl_e.parent = ex.head_hinge_e
163
164     for i, attr in enumerate(ex_chain.attr_names):
165         neck_e = getattr(ex_chain, attr + "_e")
166
167         # dont store parent names, re-reference as each chain bones parent.
168         neck_e_parent = arm.edit_bones.new("MCH-rot_%s" % base_names[getattr(mt_chain, attr)])
169         neck_e_parent.head = neck_e.head
170         neck_e_parent.tail = neck_e.head + ((mt.head_e.tail - mt.head_e.head).normalize() * neck_chain_segment_length / 2.0)
171         neck_e_parent.roll = mt.head_e.roll
172
173         orig_parent = neck_e.parent
174         neck_e.connected = False
175         neck_e.parent = neck_e_parent
176         neck_e_parent.connected = False
177
178         if i == 0:
179             neck_e_parent.parent = mt.body_e
180         else:
181             neck_e_parent.parent = orig_parent
182
183
184     bpy.ops.object.mode_set(mode='OBJECT')
185
186     mt.update()
187     mt_chain.update()
188     ex_chain.update()
189     ex.update()
190
191     # Simple one off constraints, no drivers
192     con = ex.head_ctrl_p.constraints.new('COPY_LOCATION')
193     con.target = obj
194     con.subtarget = ex.neck_socket
195
196     con = ex.head_p.constraints.new('COPY_ROTATION')
197     con.target = obj
198     con.subtarget = ex.head_ctrl
199
200     # driven hinge
201     prop = rna_idprop_ui_prop_get(ex.head_ctrl_p, "hinge", create=True)
202     ex.head_ctrl_p["hinge"] = 0.0
203     prop["soft_min"] = 0.0
204     prop["soft_max"] = 1.0
205
206     con = ex.head_hinge_p.constraints.new('COPY_ROTATION')
207     con.name = "hinge"
208     con.target = obj
209     con.subtarget = mt.body
210
211     # add driver
212     hinge_driver_path = ex.head_ctrl_p.path_to_id() + '["hinge"]'
213
214     fcurve = con.driver_add("influence", 0)
215     driver = fcurve.driver
216     tar = driver.targets.new()
217     driver.type = 'AVERAGE'
218     tar.name = "var"
219     tar.id_type = 'OBJECT'
220     tar.id = obj
221     tar.data_path = hinge_driver_path
222
223     #mod = fcurve_driver.modifiers.new('GENERATOR')
224     mod = fcurve.modifiers[0]
225     mod.poly_order = 1
226     mod.coefficients[0] = 1.0
227     mod.coefficients[1] = -1.0
228
229     head_driver_path = ex.head_ctrl_p.path_to_id()
230
231     target_names = [("b%.2d" % (i + 1)) for i in range(len(neck_chain))]
232
233     ex.head_ctrl_p["bend_tot"] = 0.0
234     fcurve = ex.head_ctrl_p.driver_add('["bend_tot"]', 0)
235     driver = fcurve.driver
236     driver.type = 'SUM'
237     fcurve.modifiers.remove(0) # grr dont need a modifier
238
239     for i in range(len(neck_chain)):
240         tar = driver.targets.new()
241         tar.name = target_names[i]
242         tar.id_type = 'OBJECT'
243         tar.id = obj
244         tar.data_path = head_driver_path + ('["bend_%.2d"]' % (i + 1))
245
246
247     for i, attr in enumerate(ex_chain.attr_names):
248         neck_p = getattr(ex_chain, attr + "_p")
249         neck_p.lock_location = True, True, True
250         neck_p.lock_location = True, True, True
251         neck_p.lock_rotations_4d = True
252
253         # Add bend prop
254         prop_name = "bend_%.2d" % (i + 1)
255         prop = rna_idprop_ui_prop_get(ex.head_ctrl_p, prop_name, create=True)
256         ex.head_ctrl_p[prop_name] = 1.0
257         prop["soft_min"] = 0.0
258         prop["soft_max"] = 1.0
259
260         # add parent constraint
261         neck_p_parent = neck_p.parent
262
263         # add constraint
264         con = neck_p_parent.constraints.new('COPY_ROTATION')
265         con.name = "Copy Rotation"
266         con.target = obj
267         con.subtarget = ex.head
268         con.owner_space = 'LOCAL'
269         con.target_space = 'LOCAL'
270
271         fcurve = con.driver_add("influence", 0)
272         driver = fcurve.driver
273         driver.type = 'SCRIPTED'
274         driver.expression = "bend/bend_tot"
275
276         fcurve.modifiers.remove(0) # grr dont need a modifier
277
278
279         # add target
280         tar = driver.targets.new()
281         tar.name = "bend_tot"
282         tar.id_type = 'OBJECT'
283         tar.id = obj
284         tar.data_path = head_driver_path + ('["bend_tot"]')
285
286         tar = driver.targets.new()
287         tar.name = "bend"
288         tar.id_type = 'OBJECT'
289         tar.id = obj
290         tar.data_path = head_driver_path + ('["%s"]' % prop_name)
291
292
293         # finally constrain the original bone to this one
294         orig_neck_p = getattr(mt_chain, attr + "_p")
295         con = orig_neck_p.constraints.new('COPY_ROTATION')
296         con.target = obj
297         con.subtarget = neck_p.name
298
299
300     # last step setup layers
301     layers = get_layer_dict(options)
302     lay = layers["extra"]
303     for attr in ex_chain.attr_names:
304         getattr(ex_chain, attr + "_b").layer = lay
305     for attr in ex.attr_names:
306         getattr(ex, attr + "_b").layer = lay
307
308
309     # no blending the result of this
310     return None