rna rename Bone and Text changes
authorCampbell Barton <ideasman42@gmail.com>
Wed, 18 Aug 2010 07:45:32 +0000 (07:45 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 18 Aug 2010 07:45:32 +0000 (07:45 +0000)
36 files changed:
release/scripts/io/import_anim_bvh.py
release/scripts/modules/graphviz_export.py
release/scripts/modules/rigify/__init__.py
release/scripts/modules/rigify/arm_biped.py
release/scripts/modules/rigify/copy.py
release/scripts/modules/rigify/delta.py
release/scripts/modules/rigify/eye_balls.py
release/scripts/modules/rigify/eye_lid.py
release/scripts/modules/rigify/finger_curl.py
release/scripts/modules/rigify/leg_biped.py
release/scripts/modules/rigify/leg_quadruped.py
release/scripts/modules/rigify/mouth.py
release/scripts/modules/rigify/neck.py
release/scripts/modules/rigify/neck_flex.py
release/scripts/modules/rigify/palm_curl.py
release/scripts/modules/rigify/shape_key_control.py
release/scripts/modules/rigify/shape_key_distance.py
release/scripts/modules/rigify/shape_key_rotdiff.py
release/scripts/modules/rigify/spine_pivot_flex.py
release/scripts/modules/rigify/stretch.py
release/scripts/modules/rigify/stretch_twist.py
release/scripts/modules/rigify/tail_control.py
release/scripts/modules/rigify/tongue.py
release/scripts/modules/rigify/track_dual.py
release/scripts/modules/rigify/track_reverse.py
release/scripts/modules/rigify_utils.py
release/scripts/op/add_armature_human.py
release/scripts/ui/properties_data_armature.py
release/scripts/ui/properties_data_bone.py
source/blender/editors/armature/poseobject.c
source/blender/editors/object/object_add.c
source/blender/editors/object/object_relations.c
source/blender/editors/object/object_select.c
source/blender/makesrna/intern/rna_armature.c
source/blender/makesrna/intern/rna_text.c
source/blender/makesrna/rna_cleanup/rna_properties.txt

index 3a80768070016652e961122e40004b84e31f0106..04cae915a49e6fa80212c343bd9101d3137ede75 100644 (file)
@@ -426,7 +426,7 @@ def bvh_node_dict2armature(context, bvh_nodes, ROT_MODE='XYZ', IMPORT_START_FRAM
             bvh_node.parent and\
             bvh_node.parent.temp.name not in ZERO_AREA_BONES and\
             bvh_node.parent.rest_tail_local == bvh_node.rest_head_local:
-                bvh_node.temp.connected = True
+                bvh_node.temp.use_connect = True
 
     # Replace the editbone with the editbone name,
     # to avoid memory errors accessing the editbone outside editmode
index 900d69670d5ff06446ee3d5e785a60efaa3ea105..2389e1f90205f0ea828b6446f8fc391d32f0bb6e 100644 (file)
@@ -66,7 +66,7 @@ def graph_armature(obj, filepath, FAKE_PARENT=True, CONSTRAINTS=True, DRIVERS=Tr
     print("")
     for bone in bones:
         b = arm.bones[bone]
-        print(">>", bone, ["*>", "->"][b.connected], getattr(getattr(b, "parent", ""), "name", ""))
+        print(">>", bone, ["*>", "->"][b.use_connect], getattr(getattr(b, "parent", ""), "name", ""))
         label = [bone]
         bone = arm.bones[bone]
 
@@ -103,7 +103,7 @@ def graph_armature(obj, filepath, FAKE_PARENT=True, CONSTRAINTS=True, DRIVERS=Tr
         parent = bone.parent
         if parent:
             parent_name = parent.name
-            connected = bone.connected
+            connected = bone.use_connect
         elif FAKE_PARENT:
             parent_name = 'Object::%s' % obj.name
             connected = False
index f38186aca281d5fdfe2947a96c1c3845a1952946..2eed5bbb74e694af57347830ca1a8049356c819e 100644 (file)
@@ -282,7 +282,7 @@ def generate_rig(context, obj_orig, prefix="ORG-", META_DEF=True):
     edit_bone.head = (0.0, 0.0, 0.0)
     edit_bone.tail = (0.0, 1.0, 0.0)
     edit_bone.roll = 0.0
-    edit_bone.layer = ROOT_LAYERS
+    edit_bone.layers = ROOT_LAYERS
     bpy.ops.object.mode_set(mode='OBJECT')
 
     # key: bone name
@@ -412,7 +412,7 @@ def generate_rig(context, obj_orig, prefix="ORG-", META_DEF=True):
                 else:
                     root_ebone_tmp = root_ebone
 
-                ebone.connected = False
+                ebone.use_connect = False
                 ebone.parent = root_ebone_tmp
             '''
 
@@ -429,7 +429,7 @@ def generate_rig(context, obj_orig, prefix="ORG-", META_DEF=True):
             con.target = obj
             con.subtarget = bone_name
 
-            if not pbone.bone.connected:
+            if not pbone.bone.use_connect:
                 con = pbone.constraints.new('COPY_LOCATION')
                 con.target = obj
                 con.subtarget = bone_name
@@ -445,23 +445,23 @@ def generate_rig(context, obj_orig, prefix="ORG-", META_DEF=True):
     layer_second_last[30] = True
 
     for bone_name, bone in arm.bones.items():
-        bone.deform = False  # Non DEF bones shouldn't deform
+        bone.use_deform = False  # Non DEF bones shouldn't deform
         if bone_name.startswith(ORG_PREFIX):
-            bone.layer = ORG_LAYERS
+            bone.layers = ORG_LAYERS
         elif bone_name.startswith(MCH_PREFIX): # XXX fixme
-            bone.layer = MCH_LAYERS
+            bone.layers = MCH_LAYERS
         elif bone_name.startswith(DEF_PREFIX): # XXX fixme
-            bone.layer = DEF_LAYERS
-            bone.deform = True
+            bone.layers = DEF_LAYERS
+            bone.use_deform = True
         else:
             # Assign bone appearance if there is a widget for it
             obj.pose.bones[bone_name].custom_shape = context.scene.objects.get(WGT_PREFIX + bone_name)
 
-        layer_tot[:] = [max(lay) for lay in zip(layer_tot, bone.layer)]
+        layer_tot[:] = [max(lay) for lay in zip(layer_tot, bone.layers)]
 
     # Only for demo'ing
     layer_show = [a and not (b or c or d) for a, b, c, d in zip(layer_tot, ORG_LAYERS, MCH_LAYERS, DEF_LAYERS)]
-    arm.layer = layer_show
+    arm.layers = layer_show
 
 
     # obj.hide = True
index f80a617df4745dbc8252b437d01f53ac90fc1c85..cbd7b522807732bd242ae2324cd00b547140ab64 100644 (file)
@@ -37,24 +37,24 @@ def metarig_template():
     bone.head[:] = 0.0000, -0.0425, 0.0000
     bone.tail[:] = 0.0942, -0.0075, 0.0333
     bone.roll = -0.2227
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('upper_arm')
     bone.head[:] = 0.1066, -0.0076, -0.0010
     bone.tail[:] = 0.2855, 0.0206, -0.0104
     bone.roll = 1.6152
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['shoulder']
     bone = arm.edit_bones.new('forearm')
     bone.head[:] = 0.2855, 0.0206, -0.0104
     bone.tail[:] = 0.4550, -0.0076, -0.0023
     bone.roll = 1.5153
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['upper_arm']
     bone = arm.edit_bones.new('hand')
     bone.head[:] = 0.4550, -0.0076, -0.0023
     bone.tail[:] = 0.5423, -0.0146, -0.0131
     bone.roll = -3.0083
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['forearm']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -78,7 +78,7 @@ def metarig_definition(obj, orig_bone_name):
     hands = []
     for pbone in obj.pose.bones:
         index = pbone.parent_index(mt.arm_p)
-        if index == 2 and pbone.bone.connected and pbone.bone.parent.connected:
+        if index == 2 and pbone.bone.use_connect and pbone.bone.parent.use_connect:
             hands.append(pbone)
 
     if len(hands) != 1:
@@ -106,12 +106,12 @@ def ik(obj, definitions, base_names, options):
     ik_chain = mt.copy(to_fmt="MCH-%s_ik", base_names=base_names, exclude_attrs=["shoulder"])
 
     # IK needs no parent_index
-    ik_chain.hand_e.connected = False
+    ik_chain.hand_e.use_connect = False
     ik_chain.hand_e.parent = None
-    ik_chain.hand_e.local_location = False
+    ik_chain.hand_e.use_local_location = False
     ik_chain.rename("hand", get_base_name(base_names[mt.hand]) + "_ik" + get_side_name(mt.hand))
 
-    ik_chain.arm_e.connected = False
+    ik_chain.arm_e.use_connect = False
     ik_chain.arm_e.parent = mt.shoulder_e
 
     # Add the bone used for the arms poll target
@@ -119,7 +119,7 @@ def ik(obj, definitions, base_names, options):
     ik.pole = add_pole_target_bone(obj, mt.forearm, "elbow_target" + get_side_name(mt.forearm), mode='ZAVERAGE')
 
     ik.update()
-    ik.pole_e.local_location = False
+    ik.pole_e.use_local_location = False
 
     # option: elbow_parent
     elbow_parent_name = options.get("elbow_parent", "")
@@ -168,11 +168,11 @@ def ik(obj, definitions, base_names, options):
     if "ik_layer" in options:
         layer = [n==options["ik_layer"] for n in range(0,32)]
     else:
-        layer = list(mt.arm_b.layer)
-    ik_chain.hand_b.layer = layer
-    ik.hand_vis_b.layer   = layer
-    ik.pole_b.layer       = layer
-    ik.pole_vis_b.layer   = layer
+        layer = list(mt.arm_b.layers)
+    ik_chain.hand_b.layers = layer
+    ik.hand_vis_b.layers   = layer
+    ik.pole_b.layers       = layer
+    ik.pole_vis_b.layers   = layer
 
     bpy.ops.object.mode_set(mode='EDIT')
     # don't blend the shoulder
@@ -197,7 +197,7 @@ def fk(obj, definitions, base_names, options):
     # upper arm constrains to this.
     ex.socket_e = copy_bone_simple(arm, mt.arm, "MCH-%s_socket" % base_names[mt.arm])
     ex.socket = ex.socket_e.name
-    ex.socket_e.connected = False
+    ex.socket_e.use_connect = False
     ex.socket_e.parent = mt.shoulder_e
     ex.socket_e.length *= 0.5
 
@@ -206,11 +206,11 @@ def fk(obj, definitions, base_names, options):
     ex.hand_delta_e = copy_bone_simple(arm, fk_chain.hand, "MCH-delta_%s" % base_names[mt.hand], parent=True)
     ex.hand_delta = ex.hand_delta_e.name
     ex.hand_delta_e.length *= 0.5
-    ex.hand_delta_e.connected = False
+    ex.hand_delta_e.use_connect = False
     if "hand_roll" in options:
         ex.hand_delta_e.roll += radians(options["hand_roll"])
 
-    fk_chain.hand_e.connected = False
+    fk_chain.hand_e.use_connect = False
     fk_chain.hand_e.parent = ex.hand_delta_e
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -273,10 +273,10 @@ def fk(obj, definitions, base_names, options):
     if "fk_layer" in options:
         layer = [n==options["fk_layer"] for n in range(0,32)]
     else:
-        layer = list(mt.arm_b.layer)
-    fk_chain.arm_b.layer     = layer
-    fk_chain.forearm_b.layer = layer
-    fk_chain.hand_b.layer    = layer
+        layer = list(mt.arm_b.layers)
+    fk_chain.arm_b.layers     = layer
+    fk_chain.forearm_b.layers = layer
+    fk_chain.hand_b.layers    = layer
 
     # Forearm was getting wrong roll somehow.  Hack to fix that.
     bpy.ops.object.mode_set(mode='EDIT')
@@ -295,8 +295,8 @@ def deform(obj, definitions, base_names, options):
     # Create upper arm bones: two bones, each half of the upper arm.
     uarm1 = copy_bone_simple(obj.data, definitions[1], "DEF-%s.01" % base_names[definitions[1]], parent=True)
     uarm2 = copy_bone_simple(obj.data, definitions[1], "DEF-%s.02" % base_names[definitions[1]], parent=True)
-    uarm1.connected = False
-    uarm2.connected = False
+    uarm1.use_connect = False
+    uarm2.use_connect = False
     uarm2.parent = uarm1
     center = uarm1.center
     uarm1.tail = center
@@ -305,8 +305,8 @@ def deform(obj, definitions, base_names, options):
     # Create forearm bones: two bones, each half of the forearm.
     farm1 = copy_bone_simple(obj.data, definitions[2], "DEF-%s.01" % base_names[definitions[2]], parent=True)
     farm2 = copy_bone_simple(obj.data, definitions[2], "DEF-%s.02" % base_names[definitions[2]], parent=True)
-    farm1.connected = False
-    farm2.connected = False
+    farm1.use_connect = False
+    farm2.use_connect = False
     farm2.parent = farm1
     center = farm1.center
     farm1.tail = center
@@ -314,7 +314,7 @@ def deform(obj, definitions, base_names, options):
 
     # Create twist bone
     twist = copy_bone_simple(obj.data, definitions[2], "MCH-arm_twist")
-    twist.connected = False
+    twist.use_connect = False
     twist.parent = obj.data.edit_bones[definitions[3]]
     twist.length /= 2
 
index e0bff555a9b27fb3979515eeb55c642246e02461..c051e5bb7f6fb626cd96431b1d019deb3b04c725 100644 (file)
@@ -33,7 +33,7 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0000, 0.0000, 1.0000
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
 
     bpy.ops.object.mode_set(mode='OBJECT')
     pbone = obj.pose.bones['Bone']
@@ -98,7 +98,7 @@ def control(obj, definitions, base_names, options):
     cp.cpy_p.lock_scale = tuple(mt.cpy_p.lock_scale)
 
     # Layers
-    cp.cpy_b.layer = list(mt.cpy_b.layer)
+    cp.cpy_b.layers = list(mt.cpy_b.layers)
 
     return (mt.cpy,)
 
index dce03b5f412439ab2b889f35311d9fcecda10ad4..d0b4fbccce9aeae8f4350b04baa3eea096fc40e5 100644 (file)
@@ -34,18 +34,18 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = -0.0000, 0.7382, 0.1895
     bone.roll = -0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('delta')
     bone.head[:] = -0.0497, 0.8414, 0.3530
     bone.tail[:] = -0.2511, 1.1588, 0.9653
     bone.roll = 2.6044
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['bonesker']
     bone = arm.edit_bones.new('boney')
     bone.head[:] = 0.7940, 2.5592, 0.4134
     bone.tail[:] = 0.7940, 3.3975, 0.4890
     bone.roll = 3.1416
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['delta']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -67,7 +67,7 @@ def metarig_definition(obj, orig_bone_name):
     if len(children) != 1:
         raise RigifyError("only 1 child supported for delta on bone '%s'" % delta.name)
 
-    if delta.connected:
+    if delta.use_connect:
         raise RigifyError("bone cannot be connected to its parent '%s'" % delta.name)
 
     bone_definition = [delta.name, children[0].name]
index 48f0448dfb39fc1faf2b7005a5f7d77aaa953c33..b1889d7c36fdebd0852f62e2eb2c29634e9b850e 100644 (file)
@@ -134,7 +134,7 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0000, 0.0000, 1.0000
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
 
     bpy.ops.object.mode_set(mode='OBJECT')
     pbone = obj.pose.bones['Bone']
@@ -379,15 +379,15 @@ def control(obj, definitions, base_names, options):
 
 
     # Set layers
-    #layer = list(bb[definitions[2]].layer)
-    #bb[lid1].layer = layer
-    #bb[lid2].layer = layer
-    #bb[lid3].layer = layer
-    #bb[lid4].layer = layer
-    #bb[lid5].layer = layer
-    #bb[lid6].layer = layer
-    #bb[lid7].layer = layer
-    #bb[lid8].layer = layer
+    #layer = list(bb[definitions[2]].layers)
+    #bb[lid1].layers = layer
+    #bb[lid2].layers = layer
+    #bb[lid3].layers = layer
+    #bb[lid4].layers = layer
+    #bb[lid5].layers = layer
+    #bb[lid6].layers = layer
+    #bb[lid7].layers = layer
+    #bb[lid8].layers = layer
 
 
     return (None,)
index bb9749011c20d030eb4257955b11d53d13a311cc..2d7e3e0e61ff48d6dcf73969aa89540aba780fdf 100644 (file)
@@ -56,7 +56,7 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0000, 0.0000, 1.0000
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
 
     bpy.ops.object.mode_set(mode='OBJECT')
     pbone = obj.pose.bones['Bone']
@@ -148,10 +148,10 @@ def deform(obj, definitions, base_names, options):
     eb[dlid3].parent  = eb[dlid4]
     eb[dlid33].parent = eb[dlid3]
 
-    eb[dlid2].connected  = True
-    eb[dlid22].connected = True
-    eb[dlid3].connected  = True
-    eb[dlid33].connected = True
+    eb[dlid2].use_connect  = True
+    eb[dlid22].use_connect = True
+    eb[dlid3].use_connect  = True
+    eb[dlid33].use_connect = True
 
     eb[dlid1].bbone_segments = 8
     eb[dlid2].bbone_segments = 8
@@ -170,10 +170,10 @@ def deform(obj, definitions, base_names, options):
     eb[dlid7].parent = eb[dlid8]
     eb[dlid77].parent = eb[dlid7]
 
-    eb[dlid6].connected = True
-    eb[dlid66].connected = True
-    eb[dlid7].connected = True
-    eb[dlid77].connected = True
+    eb[dlid6].use_connect = True
+    eb[dlid66].use_connect = True
+    eb[dlid7].use_connect = True
+    eb[dlid77].use_connect = True
 
     eb[dlid5].bbone_segments = 8
     eb[dlid6].bbone_segments = 8
@@ -615,15 +615,15 @@ def control(obj, definitions, base_names, options):
 
 
     # Set layers
-    layer = list(bb[definitions[2]].layer)
-    bb[lid1].layer = layer
-    bb[lid2].layer = layer
-    bb[lid3].layer = layer
-    bb[lid4].layer = layer
-    bb[lid5].layer = layer
-    bb[lid6].layer = layer
-    bb[lid7].layer = layer
-    bb[lid8].layer = layer
+    layer = list(bb[definitions[2]].layers)
+    bb[lid1].layers = layer
+    bb[lid2].layers = layer
+    bb[lid3].layers = layer
+    bb[lid4].layers = layer
+    bb[lid5].layers = layer
+    bb[lid6].layers = layer
+    bb[lid7].layers = layer
+    bb[lid8].layers = layer
 
 
     return (None,)
@@ -648,7 +648,7 @@ def make_lid_stretch_bone(obj, name, bone1, bone2, roll_alpha):
 
     # Create the bone, pointing from bone1 to bone2
     bone_e = copy_bone_simple(obj.data, bone1, name, parent=True)
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.tail = eb[bone2].head
     bone = bone_e.name
 
index 63f1816012bbae8e86afb7b6fe307c0c86915e58..947ec75c9f869fd425ca2e9a4570975f80207213 100644 (file)
@@ -35,18 +35,18 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0353, -0.0184, -0.0053
     bone.roll = -2.8722
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('finger.02')
     bone.head[:] = 0.0353, -0.0184, -0.0053
     bone.tail[:] = 0.0702, -0.0364, -0.0146
     bone.roll = -2.7099
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger.01']
     bone = arm.edit_bones.new('finger.03')
     bone.head[:] = 0.0702, -0.0364, -0.0146
     bone.tail[:] = 0.0903, -0.0461, -0.0298
     bone.roll = -2.1709
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger.02']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -84,8 +84,8 @@ def deform(obj, definitions, base_names, options):
     # Create base digit bones: two bones, each half of the base digit.
     f1a = copy_bone_simple(obj.data, definitions[0], "DEF-%s.01" % base_names[definitions[0]], parent=True)
     f1b = copy_bone_simple(obj.data, definitions[0], "DEF-%s.02" % base_names[definitions[0]], parent=True)
-    f1a.connected = False
-    f1b.connected = False
+    f1a.use_connect = False
+    f1b.use_connect = False
     f1b.parent = f1a
     center = f1a.center
     f1a.tail = center
@@ -182,7 +182,7 @@ def main(obj, bone_definition, base_names, options):
     else:
         tot_len = eb[org_f1].length + eb[org_f2].length
     control = copy_bone_simple(arm, bone_definition[0], base_name + get_side_name(base_names[bone_definition[0]]), parent=True).name
-    eb[control].connected = eb[org_f1].connected
+    eb[control].use_connect = eb[org_f1].use_connect
     eb[control].parent = eb[org_f1].parent
     eb[control].length = tot_len
 
@@ -203,12 +203,12 @@ def main(obj, bone_definition, base_names, options):
 
     # Set parents of the bones, interleaving the driver bones with the secondary control bones
     if three_digits:
-        eb[f3].connected = False
-        eb[df3].connected = False
-    eb[f2].connected = False
-    eb[df2].connected = False
-    eb[f1].connected = False
-    eb[df1].connected = eb[org_f1].connected
+        eb[f3].use_connect = False
+        eb[df3].use_connect = False
+    eb[f2].use_connect = False
+    eb[df2].use_connect = False
+    eb[f1].use_connect = False
+    eb[df1].use_connect = eb[org_f1].use_connect
 
     if three_digits:
         eb[f3].parent = eb[df3]
@@ -223,7 +223,7 @@ def main(obj, bone_definition, base_names, options):
         socket = copy_bone_simple(arm, org_f1, "MCH-socket_"+control, parent=True).name
         hinge = copy_bone_simple(arm, eb[org_f1].parent.name, "MCH-hinge_"+control).name
 
-        eb[control].connected = False
+        eb[control].use_connect = False
         eb[control].parent = eb[hinge]
 
     # Create the deform rig while we're still in edit mode
@@ -362,16 +362,16 @@ def main(obj, bone_definition, base_names, options):
     if "ex_layer" in options:
         layer = [n==options["ex_layer"] for n in range(0,32)]
     else:
-        layer = list(arm.bones[bone_definition[0]].layer)
+        layer = list(arm.bones[bone_definition[0]].layers)
     #for bone_name in [f1, f2, f3]:
-    #    arm.bones[bone_name].layer = layer
-    arm.bones[f1].layer = layer
-    arm.bones[f2].layer = layer
+    #    arm.bones[bone_name].layers = layer
+    arm.bones[f1].layers = layer
+    arm.bones[f2].layers = layer
     if three_digits:
-        arm.bones[f3].layer = layer
+        arm.bones[f3].layers = layer
 
-    layer = list(arm.bones[bone_definition[0]].layer)
-    bb[control].layer = layer
+    layer = list(arm.bones[bone_definition[0]].layers)
+    bb[control].layers = layer
 
     # no blending the result of this
     return None
index 53028986873c803cee21a0f8f4013a4f5ae56b7f..767bf38b157d4a117c1f3f47e97ee5825225eaa3 100644 (file)
@@ -36,36 +36,36 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0000, 0.0000, 0.2506
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('thigh')
     bone.head[:] = 0.1253, 0.0000, -0.0000
     bone.tail[:] = 0.0752, -0.0251, -0.4260
     bone.roll = 0.1171
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hips']
     bone = arm.edit_bones.new('shin')
     bone.head[:] = 0.0752, -0.0251, -0.4260
     bone.tail[:] = 0.0752, 0.0000, -0.8771
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thigh']
     bone = arm.edit_bones.new('foot')
     bone.head[:] = 0.0752, 0.0000, -0.8771
     bone.tail[:] = 0.1013, -0.1481, -0.9773
     bone.roll = -0.4662
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['shin']
     bone = arm.edit_bones.new('toe')
     bone.head[:] = 0.1013, -0.1481, -0.9773
     bone.tail[:] = 0.1100, -0.2479, -0.9773
     bone.roll = 3.1416
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['foot']
     bone = arm.edit_bones.new('heel')
     bone.head[:] = 0.0652, 0.0501, -1.0024
     bone.tail[:] = 0.0927, -0.1002, -1.0024
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['foot']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -109,11 +109,11 @@ def metarig_definition(obj, orig_bone_name):
     if len(children) != 2:
         raise RigifyError("expected the foot bone:'%s' to have 2 children" % bone.name)
 
-    if children[0].connected == children[1].connected:
+    if children[0].use_connect == children[1].use_connect:
         raise RigifyError("expected one bone to be connected")
 
     toe, heel = children
-    if heel.connected:
+    if heel.use_connect:
         toe, heel = heel, toe
 
 
@@ -154,7 +154,7 @@ def ik(obj, bone_definition, base_names, options):
     ik.foot_e = copy_bone_simple(arm, mt.heel, base_foot_name + "_ik" + get_side_name(base_names[mt_chain.foot]))
     ik.foot = ik.foot_e.name
     ik.foot_e.translate(mt_chain.foot_e.head - ik.foot_e.head)
-    ik.foot_e.local_location = False
+    ik.foot_e.use_local_location = False
 
     # foot roll: heel pointing backwards, half length
     ik.foot_roll_e = copy_bone_simple(arm, mt.heel, base_foot_name + "_roll" + get_side_name(base_names[mt_chain.foot]))
@@ -180,11 +180,11 @@ def ik(obj, bone_definition, base_names, options):
     # rename 'MCH-toe' --> to 'toe_ik' and make the child of ik.foot_roll_01
     # ------------------ FK or IK?
     ik_chain.rename("toe", get_base_name(base_names[mt_chain.toe]) + "_ik" + get_side_name(base_names[mt_chain.toe]))
-    ik_chain.toe_e.connected = False
+    ik_chain.toe_e.use_connect = False
     ik_chain.toe_e.parent = ik.foot_roll_01_e
 
     # re-parent ik_chain.foot to the
-    ik_chain.foot_e.connected = False
+    ik_chain.foot_e.use_connect = False
     ik_chain.foot_e.parent = ik.foot_roll_02_e
 
 
@@ -198,7 +198,7 @@ def ik(obj, bone_definition, base_names, options):
     ik.knee_target_e.translate(offset)
     ik.knee_target_e.length *= 0.5
     ik.knee_target_e.parent = ik.foot_e
-    ik.knee_target_e.local_location = False
+    ik.knee_target_e.use_local_location = False
 
     # roll the bone to point up... could also point in the same direction as ik.foot_roll
     # ik.foot_roll_02_e.matrix * Vector((0.0, 0.0, 1.0)) # ACK!, no rest matrix in editmode
@@ -267,11 +267,11 @@ def ik(obj, bone_definition, base_names, options):
     if "ik_layer" in options:
         layer = [n == options["ik_layer"] for n in range(0, 32)]
     else:
-        layer = list(mt_chain.thigh_b.layer)
+        layer = list(mt_chain.thigh_b.layers)
     for attr in ik_chain.attr_names:
-        getattr(ik_chain, attr + "_b").layer = layer
+        getattr(ik_chain, attr + "_b").layers = layer
     for attr in ik.attr_names:
-        getattr(ik, attr + "_b").layer = layer
+        getattr(ik, attr + "_b").layers = layer
 
     bpy.ops.object.mode_set(mode='EDIT')
 
@@ -312,11 +312,11 @@ def fk(obj, bone_definition, base_names, options):
     foot = foot_e.name
     foot_e.translate(mt_chain.foot_e.head - foot_e.head)
     foot_e.parent = fk_chain.shin_e
-    foot_e.connected = fk_chain.foot_e.connected
-    fk_chain.foot_e.connected = False
+    foot_e.use_connect = fk_chain.foot_e.use_connect
+    fk_chain.foot_e.use_connect = False
     fk_chain.foot_e.parent = foot_e
 
-    fk_chain.thigh_e.connected = False
+    fk_chain.thigh_e.use_connect = False
     fk_chain.thigh_e.parent = ex.thigh_hinge_e
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -370,12 +370,12 @@ def fk(obj, bone_definition, base_names, options):
     if "fk_layer" in options:
         layer = [n == options["fk_layer"] for n in range(0, 32)]
     else:
-        layer = list(mt_chain.thigh_b.layer)
+        layer = list(mt_chain.thigh_b.layers)
     for attr in fk_chain.attr_names:
-        getattr(fk_chain, attr + "_b").layer = layer
+        getattr(fk_chain, attr + "_b").layers = layer
     for attr in ex.attr_names:
-        getattr(ex, attr + "_b").layer = layer
-    arm.bones[foot].layer = layer
+        getattr(ex, attr + "_b").layers = layer
+    arm.bones[foot].layers = layer
 
 
     bpy.ops.object.mode_set(mode='EDIT')
@@ -390,8 +390,8 @@ def deform(obj, definitions, base_names, options):
     # Create upper leg bones: two bones, each half of the upper leg.
     uleg1 = copy_bone_simple(obj.data, definitions[1], "DEF-%s.01" % base_names[definitions[1]], parent=True)
     uleg2 = copy_bone_simple(obj.data, definitions[1], "DEF-%s.02" % base_names[definitions[1]], parent=True)
-    uleg1.connected = False
-    uleg2.connected = False
+    uleg1.use_connect = False
+    uleg2.use_connect = False
     uleg2.parent = uleg1
     center = uleg1.center
     uleg1.tail = center
@@ -400,8 +400,8 @@ def deform(obj, definitions, base_names, options):
     # Create lower leg bones: two bones, each half of the lower leg.
     lleg1 = copy_bone_simple(obj.data, definitions[2], "DEF-%s.01" % base_names[definitions[2]], parent=True)
     lleg2 = copy_bone_simple(obj.data, definitions[2], "DEF-%s.02" % base_names[definitions[2]], parent=True)
-    lleg1.connected = False
-    lleg2.connected = False
+    lleg1.use_connect = False
+    lleg2.use_connect = False
     lleg2.parent = lleg1
     center = lleg1.center
     lleg1.tail = center
@@ -410,7 +410,7 @@ def deform(obj, definitions, base_names, options):
     # Create a bone for the second lower leg deform bone to twist with
     twist = copy_bone_simple(obj.data, lleg2.name, "MCH-leg_twist")
     twist.length /= 4
-    twist.connected = False
+    twist.use_connect = False
     twist.parent = obj.data.edit_bones[definitions[3]]
 
     # Create foot bone
index 688387bbd53b5bf8aac2da7630513e07d1c70055..640e1766ca6af5a21e4f3130b802d7595090de70 100644 (file)
@@ -37,30 +37,30 @@ def metarig_template():
     bone.head[:] = -0.0728, -0.2427, 0.0000
     bone.tail[:] = -0.0728, -0.2427, 0.2427
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('thigh')
     bone.head[:] = 0.0000, 0.0000, -0.0000
     bone.tail[:] = 0.0813, -0.2109, -0.3374
     bone.roll = -0.4656
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['body']
     bone = arm.edit_bones.new('shin')
     bone.head[:] = 0.0813, -0.2109, -0.3374
     bone.tail[:] = 0.0714, -0.0043, -0.5830
     bone.roll = -0.2024
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thigh']
     bone = arm.edit_bones.new('foot')
     bone.head[:] = 0.0714, -0.0043, -0.5830
     bone.tail[:] = 0.0929, -0.0484, -0.7652
     bone.roll = -0.3766
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['shin']
     bone = arm.edit_bones.new('toe')
     bone.head[:] = 0.0929, -0.0484, -0.7652
     bone.tail[:] = 0.1146, -0.1244, -0.7652
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['foot']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -120,7 +120,7 @@ def ik(obj, bone_definition, base_names, options):
 
     ik_chain = mt_chain.copy(to_fmt="MCH-%s.ik", base_names=base_names)
 
-    ik_chain.thigh_e.connected = False
+    ik_chain.thigh_e.use_connect = False
     ik_chain.thigh_e.parent = mt.hips_e
 
     ik_chain.foot_e.parent = None
@@ -128,10 +128,10 @@ def ik(obj, bone_definition, base_names, options):
     ik_chain.rename("toe", get_base_name(base_names[bone_definition[4]]) + "_ik" + get_side_name(base_names[bone_definition[4]]))
 
     # keep the foot_ik as the parent
-    ik_chain.toe_e.connected = False
+    ik_chain.toe_e.use_connect = False
 
     # Foot uses pose space, not local space, for translation
-    ik_chain.foot_e.local_location = False
+    ik_chain.foot_e.use_local_location = False
 
     # must be after disconnecting the toe
     ik_chain.foot_e.align_orientation(mt_chain.toe_e)
@@ -141,7 +141,7 @@ def ik(obj, bone_definition, base_names, options):
 
     # knee rotator
     knee_rotator = copy_bone_simple(arm, mt_chain.toe, "knee_rotator" + get_side_name(base_names[mt_chain.foot]), parent=True).name
-    eb[knee_rotator].connected = False
+    eb[knee_rotator].use_connect = False
     eb[knee_rotator].parent = eb[mt.hips]
     eb[knee_rotator].head = eb[ik_chain.thigh].head
     eb[knee_rotator].tail = eb[knee_rotator].head + eb[mt_chain.toe].vector
@@ -156,7 +156,7 @@ def ik(obj, bone_definition, base_names, options):
     # then align it with the foot but reverse direction.
     ik.foot_roll_e = copy_bone_simple(arm, mt_chain.toe, get_base_name(base_names[mt_chain.foot]) + "_roll" + get_side_name(base_names[mt_chain.foot]))
     ik.foot_roll = ik.foot_roll_e.name
-    ik.foot_roll_e.connected = False
+    ik.foot_roll_e.use_connect = False
     ik.foot_roll_e.parent = ik_chain.foot_e
     ik.foot_roll_e.head -= mt_chain.toe_e.vector.normalize() * mt_chain.foot_e.length
     ik.foot_roll_e.tail = ik.foot_roll_e.head - (mt_chain.foot_e.vector.normalize() * mt_chain.toe_e.length)
@@ -175,7 +175,7 @@ def ik(obj, bone_definition, base_names, options):
     ik.foot_target_e.parent = ik.foot_roll_01_e
     ik.foot_target_e.align_orientation(ik_chain.foot_e)
     ik.foot_target_e.length = ik_chain.foot_e.length / 2.0
-    ik.foot_target_e.connected = True
+    ik.foot_target_e.use_connect = True
 
     # MCH-foot.02 child of MCH-foot
     ik.foot_roll_02_e = copy_bone_simple(arm, mt_chain.foot, "MCH-%s_02" % base_names[mt_chain.foot])
@@ -289,12 +289,12 @@ def ik(obj, bone_definition, base_names, options):
     if "ik_layer" in options:
         layer = [n==options["ik_layer"] for n in range(0,32)]
     else:
-        layer = list(mt_chain.thigh_b.layer)
+        layer = list(mt_chain.thigh_b.layers)
     for attr in ik_chain.attr_names:
-        obj.data.bones[getattr(ik_chain, attr)].layer = layer
+        obj.data.bones[getattr(ik_chain, attr)].layers = layer
     for attr in ik.attr_names:
-        obj.data.bones[getattr(ik, attr)].layer = layer
-    obj.data.bones[knee_rotator].layer = layer
+        obj.data.bones[getattr(ik, attr)].layers = layer
+    obj.data.bones[knee_rotator].layers = layer
 
     return None, ik_chain.thigh, ik_chain.shin, ik_chain.foot, ik_chain.toe
 
@@ -325,7 +325,7 @@ def fk(obj, bone_definition, base_names, options):
     eb[hinge].length = eb[mt.hips].length / 2
 
     # Make leg child of hinge
-    eb[fk_chain.thigh].connected = False
+    eb[fk_chain.thigh].use_connect = False
     eb[fk_chain.thigh].parent = eb[hinge]
 
 
@@ -396,8 +396,8 @@ def deform(obj, definitions, base_names, options):
     # Create upper leg bones: two bones, each half of the upper leg.
     uleg1 = copy_bone_simple(obj.data, definitions[1], "DEF-%s.01" % base_names[definitions[1]], parent=True)
     uleg2 = copy_bone_simple(obj.data, definitions[1], "DEF-%s.02" % base_names[definitions[1]], parent=True)
-    uleg1.connected = False
-    uleg2.connected = False
+    uleg1.use_connect = False
+    uleg2.use_connect = False
     uleg2.parent = uleg1
     center = uleg1.center
     uleg1.tail = center
@@ -406,8 +406,8 @@ def deform(obj, definitions, base_names, options):
     # Create lower leg bones: two bones, each half of the lower leg.
     lleg1 = copy_bone_simple(obj.data, definitions[2], "DEF-%s.01" % base_names[definitions[2]], parent=True)
     lleg2 = copy_bone_simple(obj.data, definitions[2], "DEF-%s.02" % base_names[definitions[2]], parent=True)
-    lleg1.connected = False
-    lleg2.connected = False
+    lleg1.use_connect = False
+    lleg2.use_connect = False
     lleg2.parent = lleg1
     center = lleg1.center
     lleg1.tail = center
@@ -416,7 +416,7 @@ def deform(obj, definitions, base_names, options):
     # Create a bone for the second lower leg deform bone to twist with
     twist = copy_bone_simple(obj.data, lleg2.name, "MCH-leg_twist")
     twist.length /= 4
-    twist.connected = False
+    twist.use_connect = False
     twist.parent = obj.data.edit_bones[definitions[3]]
 
     # Create foot bone
index d516a48ec95012e0b29d1dfc5a8eff15271eb87d..fff58861e02c66c358eee79fae4bf741bd8ae96c 100644 (file)
@@ -93,7 +93,7 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0000, 0.0000, 1.0000
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
 
     bpy.ops.object.mode_set(mode='OBJECT')
     pbone = obj.pose.bones['Bone']
@@ -151,8 +151,8 @@ def deform(obj, definitions, base_names, options):
     eb[spread_l_2].tail = eb[definitions[5]].head
     eb[spread_l_1].roll = 0
     eb[spread_l_2].roll = 0
-    eb[spread_l_1].connected = False
-    eb[spread_l_2].connected = False
+    eb[spread_l_1].use_connect = False
+    eb[spread_l_2].use_connect = False
     eb[spread_l_1].parent = eb[definitions[6]]
     eb[spread_l_2].parent = eb[definitions[6]]
 
@@ -162,8 +162,8 @@ def deform(obj, definitions, base_names, options):
     eb[spread_r_2].tail = eb[definitions[3]].head
     eb[spread_r_1].roll = 0
     eb[spread_r_2].roll = 0
-    eb[spread_r_1].connected = False
-    eb[spread_r_2].connected = False
+    eb[spread_r_1].use_connect = False
+    eb[spread_r_2].use_connect = False
     eb[spread_r_1].parent = eb[definitions[2]]
     eb[spread_r_2].parent = eb[definitions[2]]
 
@@ -171,7 +171,7 @@ def deform(obj, definitions, base_names, options):
 
     # Jaw open bones (for driving corrective shape keys)
     jopen1 = copy_bone_simple(obj.data, jaw, "MCH-"+base_names[jaw]+".track1", parent=True).name
-    eb[jopen1].connected = False
+    eb[jopen1].use_connect = False
     eb[jopen1].head = eb[jaw].tail
     eb[jopen1].tail = eb[jopen1].head + Vector((0, 0, eb[jaw].length/4))
 
@@ -426,7 +426,7 @@ def control(obj, definitions, base_names, options):
 
     # Jaw open tracker
     jopent = copy_bone_simple(obj.data, jaw_e.name, "MCH-"+base_names[jaw_e.name]+".track", parent=True).name
-    eb[jopent].connected = False
+    eb[jopent].use_connect = False
     eb[jopent].tail = jaw_e.tail + Vector((0.0, 0.0, jaw_e.length))
     eb[jopent].head = jaw_e.tail
 
@@ -684,15 +684,15 @@ def control(obj, definitions, base_names, options):
 
 
     # Set layers
-    layer = list(bb[definitions[2]].layer)
-    bb[lip1].layer = layer
-    bb[lip2].layer = layer
-    bb[lip3].layer = layer
-    bb[lip4].layer = layer
-    bb[lip5].layer = layer
-    bb[lip6].layer = layer
-    bb[lip7].layer = layer
-    bb[lip8].layer = layer
+    layer = list(bb[definitions[2]].layers)
+    bb[lip1].layers = layer
+    bb[lip2].layers = layer
+    bb[lip3].layers = layer
+    bb[lip4].layers = layer
+    bb[lip5].layers = layer
+    bb[lip6].layers = layer
+    bb[lip7].layers = layer
+    bb[lip8].layers = layer
 
 
     return (None,)
@@ -717,7 +717,7 @@ def make_lip_stretch_bone(obj, name, bone1, bone2, roll_alpha):
 
     # Create the bone, pointing from bone1 to bone2
     bone_e = copy_bone_simple(obj.data, bone1, name, parent=True)
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.tail = eb[bone2].head
     bone = bone_e.name
 
index 0d2ab25bcc96f833ecb79ffc4e92df62f260e7f1..56717f0ebb0e0b9b0e2c2460c06eac936f7c9a2c 100644 (file)
@@ -35,42 +35,42 @@ def metarig_template():
     #bone.head[:] = 0.0000, -0.0276, -0.1328
     #bone.tail[:] = 0.0000, -0.0170, -0.0197
     #bone.roll = 0.0000
-    #bone.connected = False
+    #bone.use_connect = False
     #bone = arm.edit_bones.new('head')
     #bone.head[:] = 0.0000, -0.0170, -0.0197
     #bone.tail[:] = 0.0000, 0.0726, 0.1354
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['body']
     #bone = arm.edit_bones.new('neck.01')
     #bone.head[:] = 0.0000, -0.0170, -0.0197
     #bone.tail[:] = 0.0000, -0.0099, 0.0146
     #bone.roll = 0.0000
-    #bone.connected = False
+    #bone.use_connect = False
     #bone.parent = arm.edit_bones['head']
     #bone = arm.edit_bones.new('neck.02')
     #bone.head[:] = 0.0000, -0.0099, 0.0146
     #bone.tail[:] = 0.0000, -0.0242, 0.0514
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.01']
     #bone = arm.edit_bones.new('neck.03')
     #bone.head[:] = 0.0000, -0.0242, 0.0514
     #bone.tail[:] = 0.0000, -0.0417, 0.0868
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.02']
     #bone = arm.edit_bones.new('neck.04')
     #bone.head[:] = 0.0000, -0.0417, 0.0868
     #bone.tail[:] = 0.0000, -0.0509, 0.1190
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.03']
     #bone = arm.edit_bones.new('neck.05')
     #bone.head[:] = 0.0000, -0.0509, 0.1190
     #bone.tail[:] = 0.0000, -0.0537, 0.1600
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.04']
     #
     #bpy.ops.object.mode_set(mode='OBJECT')
@@ -330,13 +330,13 @@ def main(obj, bone_definition, base_names, options):
     if "ex_layer" in options:
         layer = [n==options["ex_layer"] for n in range(0,32)]
     else:
-        layer = list(arm.bones[bone_definition[1]].layer)
+        layer = list(arm.bones[bone_definition[1]].layers)
     for bone in neck:
-        bb[bone].layer = layer
+        bb[bone].layers = layer
 
-    layer = list(arm.bones[bone_definition[1]].layer)
-    bb[neck_ctrl].layer = layer
-    bb[head_ctrl].layer = layer
+    layer = list(arm.bones[bone_definition[1]].layers)
+    bb[neck_ctrl].layers = layer
+    bb[head_ctrl].layers = layer
 
 
     # no blending the result of this
index 08f963434d1d2156d5987257cd9abdc8c8e7fd4d..1ab14e281b958c05f2a8eb8043d83a6f9eeb57c3 100644 (file)
@@ -36,42 +36,42 @@ def metarig_template():
     bone.head[:] = 0.0000, -0.0276, -0.1328
     bone.tail[:] = 0.0000, -0.0170, -0.0197
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('head')
     bone.head[:] = 0.0000, -0.0170, -0.0197
     bone.tail[:] = 0.0000, 0.0726, 0.1354
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['body']
     bone = arm.edit_bones.new('neck.01')
     bone.head[:] = 0.0000, -0.0170, -0.0197
     bone.tail[:] = 0.0000, -0.0099, 0.0146
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['head']
     bone = arm.edit_bones.new('neck.02')
     bone.head[:] = 0.0000, -0.0099, 0.0146
     bone.tail[:] = 0.0000, -0.0242, 0.0514
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['neck.01']
     bone = arm.edit_bones.new('neck.03')
     bone.head[:] = 0.0000, -0.0242, 0.0514
     bone.tail[:] = 0.0000, -0.0417, 0.0868
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['neck.02']
     bone = arm.edit_bones.new('neck.04')
     bone.head[:] = 0.0000, -0.0417, 0.0868
     bone.tail[:] = 0.0000, -0.0509, 0.1190
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['neck.03']
     bone = arm.edit_bones.new('neck.05')
     bone.head[:] = 0.0000, -0.0509, 0.1190
     bone.tail[:] = 0.0000, -0.0537, 0.1600
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['neck.04']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -156,7 +156,7 @@ def main(obj, bone_definition, base_names, options):
 
     # Copy the head bone and offset
     ex.head_e = copy_bone_simple(arm, mt.head, "MCH-%s" % base_names[mt.head], parent=True)
-    ex.head_e.connected = False
+    ex.head_e.use_connect = False
     ex.head = ex.head_e.name
     # offset
     head_length = ex.head_e.length
@@ -165,7 +165,7 @@ def main(obj, bone_definition, base_names, options):
 
     # Yes, use the body bone but call it a head hinge
     ex.head_hinge_e = copy_bone_simple(arm, mt.body, "MCH-%s_hinge" % base_names[mt.head], parent=False)
-    ex.head_hinge_e.connected = False
+    ex.head_hinge_e.use_connect = False
     ex.head_hinge = ex.head_hinge_e.name
     ex.head_hinge_e.head.y += head_length / 4.0
     ex.head_hinge_e.tail.y += head_length / 4.0
@@ -173,7 +173,7 @@ def main(obj, bone_definition, base_names, options):
     # Insert the neck socket, the head copys this loation
     ex.neck_socket_e = arm.edit_bones.new("MCH-%s_socked" % neck_chain_basename)
     ex.neck_socket = ex.neck_socket_e.name
-    ex.neck_socket_e.connected = False
+    ex.neck_socket_e.use_connect = False
     ex.neck_socket_e.parent = mt.body_e
     ex.neck_socket_e.head = mt.head_e.head
     ex.neck_socket_e.tail = mt.head_e.head - Vector((0.0, neck_chain_segment_length / 2.0, 0.0))
@@ -195,9 +195,9 @@ def main(obj, bone_definition, base_names, options):
         neck_e_parent.roll = mt.head_e.roll
 
         orig_parent = neck_e.parent
-        neck_e.connected = False
+        neck_e.use_connect = False
         neck_e.parent = neck_e_parent
-        neck_e_parent.connected = False
+        neck_e_parent.use_connect = False
 
         if i == 0:
             neck_e_parent.parent = mt.body_e
@@ -334,14 +334,14 @@ def main(obj, bone_definition, base_names, options):
     if "ex_layer" in options:
         layer = [n == options["ex_layer"] for n in range(0, 32)]
     else:
-        layer = list(arm.bones[bone_definition[1]].layer)
+        layer = list(arm.bones[bone_definition[1]].layers)
     for attr in ex_chain.attr_names:
-        getattr(ex_chain, attr + "_b").layer = layer
+        getattr(ex_chain, attr + "_b").layers = layer
     for attr in ex.attr_names:
-        getattr(ex, attr + "_b").layer = layer
+        getattr(ex, attr + "_b").layers = layer
 
-    layer = list(arm.bones[bone_definition[1]].layer)
-    ex.head_ctrl_b.layer = layer
+    layer = list(arm.bones[bone_definition[1]].layers)
+    ex.head_ctrl_b.layers = layer
 
 
     # no blending the result of this
index 2bdd28a348a0e396fc32c45e3f69d416927f1b3c..369d6928e45191764394cc678e67b0c4f340aab8 100644 (file)
@@ -35,42 +35,42 @@ def metarig_template():
     bone.head[:] = 0.0004, -0.0629, 0.0000
     bone.tail[:] = 0.0021, -0.0209, 0.0000
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('palm.03')
     bone.head[:] = -0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0025, 0.0644, -0.0065
     bone.roll = -3.1396
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand']
     bone = arm.edit_bones.new('palm.02')
     bone.head[:] = 0.0252, -0.0000, 0.0000
     bone.tail[:] = 0.0324, 0.0627, -0.0065
     bone.roll = -3.1357
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand']
     bone = arm.edit_bones.new('palm.01')
     bone.head[:] = 0.0504, 0.0000, 0.0000
     bone.tail[:] = 0.0703, 0.0508, -0.0065
     bone.roll = -3.1190
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand']
     bone = arm.edit_bones.new('palm.04')
     bone.head[:] = -0.0252, 0.0000, 0.0000
     bone.tail[:] = -0.0286, 0.0606, -0.0065
     bone.roll = 3.1386
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand']
     bone = arm.edit_bones.new('palm.05')
     bone.head[:] = -0.0504, 0.0000, 0.0000
     bone.tail[:] = -0.0669, 0.0534, -0.0065
     bone.roll = 3.1239
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand']
     bone = arm.edit_bones.new('thumb')
     bone.head[:] = 0.0682, -0.0148, 0.0000
     bone.tail[:] = 0.1063, 0.0242, -0.0065
     bone.roll = -3.0929
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -263,7 +263,7 @@ def main(obj, bone_definition, base_names, options):
 
 
     # last step setup layers
-    arm.bones[control_name].layer = list(arm.bones[bone_definition[1]].layer)
+    arm.bones[control_name].layers = list(arm.bones[bone_definition[1]].layers)
 
 
     # no blending the result of this
index ac3987ca7e14565f2a3a6eecce21d95b9ed202eb..1bfca60255d8db7015fd73ea61a120d8c8ec47c7 100644 (file)
@@ -74,7 +74,7 @@ def metarig_template():
     #bone.head[:] = 0.0000, 0.0000, 0.0000
     #bone.tail[:] = 0.0000, 0.0000, 1.0000
     #bone.roll = 0.0000
-    #bone.connected = False
+    #bone.use_connect = False
     #
     #bpy.ops.object.mode_set(mode='OBJECT')
     #pbone = obj.pose.bones['Bone']
index 06dd3d67d4b1c7434d1c01ee69ba9e376f88a5d0..7d69517216f6a30410e4207a864fdca86568358f 100644 (file)
@@ -71,7 +71,7 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0000, 0.0000, 1.0000
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
 
     bpy.ops.object.mode_set(mode='OBJECT')
     pbone = obj.pose.bones['Bone']
index 7049bcf74bb03f4b682da8f514abbeb61fa151ed..dfc3b914a6ad2ad6c537ab4898d31a3248c0f217 100644 (file)
@@ -71,7 +71,7 @@ def metarig_template():
     bone.head[:] = 0.0000, 0.0000, 0.0000
     bone.tail[:] = 0.0000, 0.0000, 1.0000
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
 
     bpy.ops.object.mode_set(mode='OBJECT')
     pbone = obj.pose.bones['Bone']
index c4c9886e2e2e8488f4a83d6869d4b0acc99ce5f4..645ee4045cc5e91c2a99f4025162beb1070f7091 100644 (file)
@@ -36,54 +36,54 @@ def metarig_template():
     bone.head[:] = 0.0000, -0.0306, 0.1039
     bone.tail[:] = 0.0000, -0.0306, -0.0159
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('rib_cage')
     bone.head[:] = 0.0000, -0.0306, 0.1039
     bone.tail[:] = 0.0000, -0.0306, 0.2236
     bone.roll = -0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['pelvis']
     bone = arm.edit_bones.new('spine.01')
     bone.head[:] = 0.0000, 0.0000, -0.0000
     bone.tail[:] = 0.0000, -0.0306, 0.1039
     bone.roll = -0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['rib_cage']
     bone = arm.edit_bones.new('spine.02')
     bone.head[:] = 0.0000, -0.0306, 0.1039
     bone.tail[:] = -0.0000, -0.0398, 0.2045
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.01']
     bone = arm.edit_bones.new('spine.03')
     bone.head[:] = -0.0000, -0.0398, 0.2045
     bone.tail[:] = -0.0000, -0.0094, 0.2893
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.02']
     bone = arm.edit_bones.new('spine.04')
     bone.head[:] = -0.0000, -0.0094, 0.2893
     bone.tail[:] = -0.0000, 0.0335, 0.3595
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.03']
     bone = arm.edit_bones.new('spine.05')
     bone.head[:] = -0.0000, 0.0335, 0.3595
     bone.tail[:] = -0.0000, 0.0555, 0.4327
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.04']
     bone = arm.edit_bones.new('spine.06')
     bone.head[:] = -0.0000, 0.0555, 0.4327
     bone.tail[:] = -0.0000, 0.0440, 0.5207
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.05']
     bone = arm.edit_bones.new('spine.07')
     bone.head[:] = -0.0000, 0.0440, 0.5207
     bone.tail[:] = -0.0000, 0.0021, 0.5992
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.06']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -172,7 +172,7 @@ def main(obj, bone_definition, base_names, options):
 
     ex.pelvis_copy_e = copy_bone_simple(arm, mt.pelvis, base_names[mt.pelvis]) # no parent
     ex.pelvis_copy = ex.pelvis_copy_e.name
-    ex.pelvis_copy_e.local_location = False
+    ex.pelvis_copy_e.use_local_location = False
 
     # copy the pelvis, offset to make MCH-spine_rotate and MCH-ribcage_hinge
     ex.ribcage_hinge_e = copy_bone_simple(arm, mt.pelvis, "MCH-%s_hinge" % base_names[mt.ribcage])
@@ -182,7 +182,7 @@ def main(obj, bone_definition, base_names, options):
     ex.spine_rotate_e = copy_bone_simple(arm, mt.ribcage, "MCH-%s_rotate" % spine_chain_basename)
     ex.spine_rotate = ex.spine_rotate_e.name
     ex.spine_rotate_e.translate(Vector((0.0, spine_chain_segment_length / 2.0, 0.0)))
-    ex.spine_rotate_e.connected = False
+    ex.spine_rotate_e.use_connect = False
     ex.spine_rotate_e.parent = ex.pelvis_copy_e
 
 
@@ -191,7 +191,7 @@ def main(obj, bone_definition, base_names, options):
 
     ex.ribcage_copy_e = copy_bone_simple(arm, mt.ribcage, base_names[mt.ribcage])
     ex.ribcage_copy = ex.ribcage_copy_e.name
-    ex.ribcage_copy_e.connected = False
+    ex.ribcage_copy_e.use_connect = False
     ex.ribcage_copy_e.parent = ex.ribcage_hinge_e
 
     spine_chain = [child.name for child in spine_chain]
@@ -219,7 +219,7 @@ def main(obj, bone_definition, base_names, options):
 
         ebone = copy_bone_simple(arm, child_name, "MCH-rev_%s" % child_name_orig)
         setattr(rv_chain, attr, ebone.name)
-        ebone.connected = False
+        ebone.use_connect = False
 
     mt_chain.update()
     ex_chain.update()
@@ -230,7 +230,7 @@ def main(obj, bone_definition, base_names, options):
         attr = ex_chain.attr_names[i] + "_e"
         ebone = getattr(ex_chain, attr)
         if i == 0:
-            ebone.connected = False
+            ebone.use_connect = False
             ebone.parent = ex.pelvis_copy_e
         else:
             attr_parent = ex_chain.attr_names[i - 1] + "_e"
@@ -255,9 +255,9 @@ def main(obj, bone_definition, base_names, options):
 
         spine_e = getattr(ex_chain, ex_chain.attr_names[i] + "_e")
         orig_parent = spine_e.parent
-        spine_e.connected = False
+        spine_e.use_connect = False
         spine_e.parent = spine_e_parent
-        spine_e_parent.connected = False
+        spine_e_parent.use_connect = False
 
         spine_e_parent.parent = orig_parent
 
@@ -465,17 +465,17 @@ def main(obj, bone_definition, base_names, options):
     if "ex_layer" in options:
         layer = [n == options["ex_layer"] for n in range(0, 32)]
     else:
-        layer = list(arm.bones[bone_definition[1]].layer)
+        layer = list(arm.bones[bone_definition[1]].layers)
     for attr in ex.attr_names:
-        getattr(ex, attr + "_b").layer = layer
+        getattr(ex, attr + "_b").layers = layer
     for attr in ex_chain.attr_names:
-        getattr(ex_chain, attr + "_b").layer = layer
+        getattr(ex_chain, attr + "_b").layers = layer
     for attr in rv_chain.attr_names:
-        getattr(rv_chain, attr + "_b").layer = layer
+        getattr(rv_chain, attr + "_b").layers = layer
 
-    layer = list(arm.bones[bone_definition[1]].layer)
-    arm.bones[ex.pelvis_copy].layer = layer
-    arm.bones[ex.ribcage_copy].layer = layer
+    layer = list(arm.bones[bone_definition[1]].layers)
+    arm.bones[ex.pelvis_copy].layers = layer
+    arm.bones[ex.ribcage_copy].layers = layer
 
     # no support for blending chains
     return None
index 1c3d317b4b17b814bae39bc1fe75be019390de13..67ceeb39954e561f27191d75b8ca9f41aa717f06 100644 (file)
@@ -35,7 +35,7 @@ RIG_TYPE = "stretch"
 #    bone.head[:] = 0.0000, 0.0000, 0.0000
 #    bone.tail[:] = 0.0000, 0.0000, 1.0000
 #    bone.roll = 0.0000
-#    bone.connected = False
+#    bone.use_connect = False
 #
 #    bpy.ops.object.mode_set(mode='OBJECT')
 #    pbone = obj.pose.bones['Bone']
@@ -84,7 +84,7 @@ def main(obj, bone_definition, base_names, options):
     mbone2 = "ORG-" + options["to"]
 
     bone_e = copy_bone_simple(obj.data, mbone1, "DEF-%s" % base_names[bone_definition[0]])
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.parent = eb[mbone1]
     bone_e.tail = eb[mbone2].head
     bone = bone_e.name
index 66719d80d423904ef1f32f6980439e92fb92b509..5250c5a9735bbb63e33d1b19447e9392afa76c79 100644 (file)
@@ -35,7 +35,7 @@ RIG_TYPE = "stretch_twist"
 #    bone.head[:] = 0.0000, 0.0000, 0.0000
 #    bone.tail[:] = 0.0000, 0.0000, 1.0000
 #    bone.roll = 0.0000
-#    bone.connected = False
+#    bone.use_connect = False
 #
 #    bpy.ops.object.mode_set(mode='OBJECT')
 #    pbone = obj.pose.bones['Bone']
@@ -86,20 +86,20 @@ def main(obj, bone_definition, base_names, options):
     mbone2 = "ORG-" + options["to"]
 
     bone_e = copy_bone_simple(obj.data, mbone1, "MCH-%s" % base_names[bone_definition[0]])
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.parent = None
     bone_e.head = (eb[mbone1].head + eb[mbone2].head) / 2
     bone_e.tail = (bone_e.head[0], bone_e.head[1], bone_e.head[2]+0.1)
     mid_bone = bone_e.name
 
     bone_e = copy_bone_simple(obj.data, mbone1, "DEF-%s.01" % base_names[bone_definition[0]])
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.parent = eb[mbone1]
     bone_e.tail = eb[mid_bone].head
     bone1 = bone_e.name
 
     bone_e = copy_bone_simple(obj.data, mbone2, "DEF-%s.02" % base_names[bone_definition[0]])
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.parent = eb[mbone2]
     bone_e.tail = eb[mid_bone].head
     bone2 = bone_e.name
index a629487c0c83c86a3ec5141cdcd616390c8e0acc..50a9bb236dac70c93c0a9094a45f0e0ab077b100 100644 (file)
@@ -40,7 +40,7 @@ def metarig_template():
     #bone.head[:] = 0.0000, -0.0306, 0.1039
     #bone.tail[:] = 0.0000, -0.0306, -0.0159
     #bone.roll = 0.0000
-    #bone.connected = False
+    #bone.use_connect = False
 
     #bpy.ops.object.mode_set(mode='OBJECT')
     #pbone = obj.pose.bones['tail.01']
@@ -85,9 +85,9 @@ def main(obj, bone_definitions, base_names, options):
     for bone_def in bone_definitions:
         bone = copy_bone_simple(arm, bone_def, base_names[bone_def], parent=True).name
         if i == 1:  # Don't change parent of first tail bone
-            eb[bone].connected = False
+            eb[bone].use_connect = False
             eb[bone].parent = eb[hinge2]
-            eb[bone].local_location = False
+            eb[bone].use_local_location = False
         i = 1
         bones += [bone]
 
index b6dfe756b71292aae1ffe8cd00e490bb466c1e55..fd32f3d05560e0c327a81490fee9e37212804e9e 100644 (file)
@@ -37,42 +37,42 @@ def metarig_template():
     #bone.head[:] = 0.0000, -0.0276, -0.1328
     #bone.tail[:] = 0.0000, -0.0170, -0.0197
     #bone.roll = 0.0000
-    #bone.connected = False
+    #bone.use_connect = False
     #bone = arm.edit_bones.new('head')
     #bone.head[:] = 0.0000, -0.0170, -0.0197
     #bone.tail[:] = 0.0000, 0.0726, 0.1354
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['body']
     #bone = arm.edit_bones.new('neck.01')
     #bone.head[:] = 0.0000, -0.0170, -0.0197
     #bone.tail[:] = 0.0000, -0.0099, 0.0146
     #bone.roll = 0.0000
-    #bone.connected = False
+    #bone.use_connect = False
     #bone.parent = arm.edit_bones['head']
     #bone = arm.edit_bones.new('neck.02')
     #bone.head[:] = 0.0000, -0.0099, 0.0146
     #bone.tail[:] = 0.0000, -0.0242, 0.0514
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.01']
     #bone = arm.edit_bones.new('neck.03')
     #bone.head[:] = 0.0000, -0.0242, 0.0514
     #bone.tail[:] = 0.0000, -0.0417, 0.0868
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.02']
     #bone = arm.edit_bones.new('neck.04')
     #bone.head[:] = 0.0000, -0.0417, 0.0868
     #bone.tail[:] = 0.0000, -0.0509, 0.1190
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.03']
     #bone = arm.edit_bones.new('neck.05')
     #bone.head[:] = 0.0000, -0.0509, 0.1190
     #bone.tail[:] = 0.0000, -0.0537, 0.1600
     #bone.roll = 0.0000
-    #bone.connected = True
+    #bone.use_connect = True
     #bone.parent = arm.edit_bones['neck.04']
     #
     #bpy.ops.object.mode_set(mode='OBJECT')
@@ -159,7 +159,7 @@ def main(obj, bone_definition, base_names, options):
 
     # Copy the head bone and offset
     ex.head_e = copy_bone_simple(arm, mt.head, "MCH-%s" % base_names[mt.head], parent=True)
-    ex.head_e.connected = False
+    ex.head_e.use_connect = False
     ex.head = ex.head_e.name
     # offset
     head_length = ex.head_e.length
@@ -168,7 +168,7 @@ def main(obj, bone_definition, base_names, options):
 
     # Yes, use the body bone but call it a head hinge
     ex.head_hinge_e = copy_bone_simple(arm, mt.body, "MCH-%s_hinge" % base_names[mt.head], parent=False)
-    ex.head_hinge_e.connected = False
+    ex.head_hinge_e.use_connect = False
     ex.head_hinge = ex.head_hinge_e.name
     ex.head_hinge_e.head.y += head_length / 4.0
     ex.head_hinge_e.tail.y += head_length / 4.0
@@ -176,7 +176,7 @@ def main(obj, bone_definition, base_names, options):
     # Insert the neck socket, the head copys this loation
     ex.neck_socket_e = arm.edit_bones.new("MCH-%s_socked" % neck_chain_basename)
     ex.neck_socket = ex.neck_socket_e.name
-    ex.neck_socket_e.connected = False
+    ex.neck_socket_e.use_connect = False
     ex.neck_socket_e.parent = mt.body_e
     ex.neck_socket_e.head = mt.head_e.head
     ex.neck_socket_e.tail = mt.head_e.head - Vector((0.0, neck_chain_segment_length / 2.0, 0.0))
@@ -198,9 +198,9 @@ def main(obj, bone_definition, base_names, options):
         neck_e_parent.roll = mt.head_e.roll
 
         orig_parent = neck_e.parent
-        neck_e.connected = False
+        neck_e.use_connect = False
         neck_e.parent = neck_e_parent
-        neck_e_parent.connected = False
+        neck_e_parent.use_connect = False
 
         if i == 0:
             neck_e_parent.parent = mt.body_e
@@ -346,14 +346,14 @@ def main(obj, bone_definition, base_names, options):
     if "ex_layer" in options:
         layer = [n==options["ex_layer"] for n in range(0,32)]
     else:
-        layer = list(arm.bones[bone_definition[1]].layer)
+        layer = list(arm.bones[bone_definition[1]].layers)
     for attr in ex_chain.attr_names:
-        getattr(ex_chain, attr + "_b").layer = layer
+        getattr(ex_chain, attr + "_b").layers = layer
     for attr in ex.attr_names:
-        getattr(ex, attr + "_b").layer = layer
+        getattr(ex, attr + "_b").layers = layer
 
-    layer = list(arm.bones[bone_definition[1]].layer)
-    ex.head_ctrl_b.layer = layer
+    layer = list(arm.bones[bone_definition[1]].layers)
+    ex.head_ctrl_b.layers = layer
 
 
     # no blending the result of this
index 38c2a86ab3237a9275b51546804a58ee4ed28749..f9c48a3bfcb8e80896f3c260c3e5374f7f528696 100644 (file)
@@ -35,7 +35,7 @@ RIG_TYPE = "track_dual"
 #    bone.head[:] = 0.0000, 0.0000, 0.0000
 #    bone.tail[:] = 0.0000, 0.0000, 1.0000
 #    bone.roll = 0.0000
-#    bone.connected = False
+#    bone.use_connect = False
 #
 #    bpy.ops.object.mode_set(mode='OBJECT')
 #    pbone = obj.pose.bones['Bone']
@@ -76,13 +76,13 @@ def main(obj, bone_definition, base_names, options):
     mbone2 = "ORG-" + options["to"]
 
     bone_e = copy_bone_simple(obj.data, mbone1, "DEF-%s.01" % base_names[bone_definition[0]])
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.parent = eb[mbone1]
     bone_e.tail = (eb[mbone1].head + eb[mbone2].head) / 2
     bone1 = bone_e.name
 
     bone_e = copy_bone_simple(obj.data, mbone2, "DEF-%s.02" % base_names[bone_definition[0]])
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.parent = eb[mbone1]
     bone_e.tail = (eb[mbone1].head + eb[mbone2].head) / 2
     bone2 = bone_e.name
index 21d38c28920fcd2636c6dfbc1bc338e96073306a..a65ac0e941684a3de910a4e84232878d2c5553f0 100644 (file)
@@ -35,7 +35,7 @@ RIG_TYPE = "track_reverse"
 #    bone.head[:] = 0.0000, 0.0000, 0.0000
 #    bone.tail[:] = 0.0000, 0.0000, 1.0000
 #    bone.roll = 0.0000
-#    bone.connected = False
+#    bone.use_connect = False
 #
 #    bpy.ops.object.mode_set(mode='OBJECT')
 #    pbone = obj.pose.bones['Bone']
@@ -78,7 +78,7 @@ def main(obj, bone_definition, base_names, options):
     mbone2 = "ORG-" + options["to"]
 
     bone_e = copy_bone_simple(obj.data, mbone2, "DEF-%s.02" % base_names[bone_definition[0]])
-    bone_e.connected = False
+    bone_e.use_connect = False
     bone_e.parent = eb[mbone1]
     bone_e.tail = eb[mbone1].head
     bone = bone_e.name
index 25ab6bebf48da5644bfe0cdf4616bd66727a4718..39481b37f598805cbc93b2e00a9fee32b124d2e4 100644 (file)
@@ -81,13 +81,13 @@ def copy_bone_simple(arm, from_bone, name, parent=False):
     ebone_new = arm.edit_bones.new(name)
 
     if parent:
-        ebone_new.connected = ebone.connected
+        ebone_new.use_connect = ebone.use_connect
         ebone_new.parent = ebone.parent
 
     ebone_new.head = ebone.head
     ebone_new.tail = ebone.tail
     ebone_new.roll = ebone.roll
-    ebone_new.layer = list(ebone.layer)
+    ebone_new.layers = list(ebone.layers)
     return ebone_new
 
 
@@ -276,7 +276,7 @@ def write_meta_rig(obj, func_name="metarig_template"):
         code.append("    bone.head[:] = %.4f, %.4f, %.4f" % bone.head.to_tuple(4))
         code.append("    bone.tail[:] = %.4f, %.4f, %.4f" % bone.tail.to_tuple(4))
         code.append("    bone.roll = %.4f" % bone.roll)
-        code.append("    bone.connected = %s" % str(bone.connected))
+        code.append("    bone.use_connect = %s" % str(bone.use_connect))
         if bone.parent:
             code.append("    bone.parent = arm.edit_bones['%s']" % bone.parent.name)
 
index 5d6ec1f559fa9a441433eed503534c0f0f4a715e..e0558e843157cac05b604d7e697d46884f605fa1 100644 (file)
@@ -33,426 +33,426 @@ def metarig_template():
     bone.head[:] = -0.0000, -0.0145, 1.1263
     bone.tail[:] = -0.0000, -0.0145, 0.9563
     bone.roll = 3.1416
-    bone.connected = False
+    bone.use_connect = False
     bone = arm.edit_bones.new('torso')
     bone.head[:] = -0.0000, -0.0145, 1.1263
     bone.tail[:] = -0.0000, -0.0145, 1.2863
     bone.roll = 3.1416
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['pelvis']
     bone = arm.edit_bones.new('spine.01')
     bone.head[:] = 0.0000, 0.0394, 0.9688
     bone.tail[:] = -0.0000, -0.0145, 1.1263
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['torso']
     bone = arm.edit_bones.new('spine.02')
     bone.head[:] = -0.0000, -0.0145, 1.1263
     bone.tail[:] = -0.0000, -0.0213, 1.2884
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.01']
     bone = arm.edit_bones.new('thigh.L')
     bone.head[:] = 0.0933, -0.0421, 1.0434
     bone.tail[:] = 0.0933, -0.0516, 0.5848
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['spine.01']
     bone = arm.edit_bones.new('thigh.R')
     bone.head[:] = -0.0933, -0.0421, 1.0434
     bone.tail[:] = -0.0933, -0.0516, 0.5848
     bone.roll = -0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['spine.01']
     bone = arm.edit_bones.new('spine.03')
     bone.head[:] = -0.0000, -0.0213, 1.2884
     bone.tail[:] = -0.0000, 0.0160, 1.3705
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.02']
     bone = arm.edit_bones.new('shin.L')
     bone.head[:] = 0.0933, -0.0516, 0.5848
     bone.tail[:] = 0.0915, 0.0100, 0.1374
     bone.roll = 0.0034
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thigh.L']
     bone = arm.edit_bones.new('shin.R')
     bone.head[:] = -0.0933, -0.0516, 0.5848
     bone.tail[:] = -0.0915, 0.0100, 0.1374
     bone.roll = -0.0034
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thigh.R']
     bone = arm.edit_bones.new('spine.04')
     bone.head[:] = -0.0000, 0.0160, 1.3705
     bone.tail[:] = -0.0000, 0.0590, 1.4497
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.03']
     bone = arm.edit_bones.new('foot.L')
     bone.head[:] = 0.0915, 0.0100, 0.1374
     bone.tail[:] = 0.1033, -0.0968, 0.0510
     bone.roll = 2.8964
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['shin.L']
     bone = arm.edit_bones.new('foot.R')
     bone.head[:] = -0.0915, 0.0100, 0.1374
     bone.tail[:] = -0.1033, -0.0968, 0.0510
     bone.roll = -2.8793
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['shin.R']
     bone = arm.edit_bones.new('neck_base')
     bone.head[:] = -0.0000, 0.0590, 1.4497
     bone.tail[:] = -0.0000, 0.0401, 1.5389
     bone.roll = -0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['spine.04']
     bone = arm.edit_bones.new('toe.L')
     bone.head[:] = 0.1033, -0.0968, 0.0510
     bone.tail[:] = 0.1136, -0.1848, 0.0510
     bone.roll = 0.0001
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['foot.L']
     bone = arm.edit_bones.new('heel.L')
     bone.head[:] = 0.0809, 0.0969, -0.0000
     bone.tail[:] = 0.1020, -0.0846, -0.0000
     bone.roll = -0.0001
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['foot.L']
     bone = arm.edit_bones.new('toe.R')
     bone.head[:] = -0.1033, -0.0968, 0.0510
     bone.tail[:] = -0.1136, -0.1848, 0.0510
     bone.roll = -0.0002
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['foot.R']
     bone = arm.edit_bones.new('heel.R')
     bone.head[:] = -0.0809, 0.0969, -0.0000
     bone.tail[:] = -0.1020, -0.0846, -0.0000
     bone.roll = -0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['foot.R']
     bone = arm.edit_bones.new('head')
     bone.head[:] = -0.0000, 0.0401, 1.5389
     bone.tail[:] = -0.0000, 0.0401, 1.5979
     bone.roll = 3.1416
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['neck_base']
     bone = arm.edit_bones.new('DLT-shoulder.L')
     bone.head[:] = 0.0141, -0.0346, 1.4991
     bone.tail[:] = 0.1226, 0.0054, 1.4991
     bone.roll = 0.0005
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['neck_base']
     bone = arm.edit_bones.new('DLT-shoulder.R')
     bone.head[:] = -0.0141, -0.0346, 1.4991
     bone.tail[:] = -0.1226, 0.0054, 1.4991
     bone.roll = -0.0005
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['neck_base']
     bone = arm.edit_bones.new('neck.01')
     bone.head[:] = -0.0000, 0.0401, 1.5389
     bone.tail[:] = -0.0000, 0.0176, 1.5916
     bone.roll = 0.0000
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['head']
     bone = arm.edit_bones.new('shoulder.L')
     bone.head[:] = 0.0141, -0.0346, 1.4991
     bone.tail[:] = 0.1226, 0.0216, 1.5270
     bone.roll = -0.1225
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['DLT-shoulder.L']
     bone = arm.edit_bones.new('shoulder.R')
     bone.head[:] = -0.0141, -0.0346, 1.4991
     bone.tail[:] = -0.1226, 0.0216, 1.5270
     bone.roll = 0.0849
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['DLT-shoulder.R']
     bone = arm.edit_bones.new('neck.02')
     bone.head[:] = -0.0000, 0.0176, 1.5916
     bone.tail[:] = -0.0000, 0.0001, 1.6499
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['neck.01']
     bone = arm.edit_bones.new('DLT-upper_arm.L')
     bone.head[:] = 0.1482, 0.0483, 1.4943
     bone.tail[:] = 0.2586, 0.1057, 1.5124
     bone.roll = 1.4969
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['shoulder.L']
     bone = arm.edit_bones.new('DLT-upper_arm.R')
     bone.head[:] = -0.1482, 0.0483, 1.4943
     bone.tail[:] = -0.2586, 0.1057, 1.5124
     bone.roll = -1.4482
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['shoulder.R']
     bone = arm.edit_bones.new('neck.03')
     bone.head[:] = -0.0000, 0.0001, 1.6499
     bone.tail[:] = -0.0000, 0.0001, 1.8522
     bone.roll = 0.0000
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['neck.02']
     bone = arm.edit_bones.new('upper_arm.L')
     bone.head[:] = 0.1482, 0.0483, 1.4943
     bone.tail[:] = 0.3929, 0.0522, 1.4801
     bone.roll = 1.6281
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['DLT-upper_arm.L']
     bone = arm.edit_bones.new('upper_arm.R')
     bone.head[:] = -0.1482, 0.0483, 1.4943
     bone.tail[:] = -0.3929, 0.0522, 1.4801
     bone.roll = -1.6281
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['DLT-upper_arm.R']
     bone = arm.edit_bones.new('forearm.L')
     bone.head[:] = 0.3929, 0.0522, 1.4801
     bone.tail[:] = 0.6198, 0.0364, 1.4906
     bone.roll = 1.5240
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['upper_arm.L']
     bone = arm.edit_bones.new('forearm.R')
     bone.head[:] = -0.3929, 0.0522, 1.4801
     bone.tail[:] = -0.6198, 0.0364, 1.4906
     bone.roll = -1.5219
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['upper_arm.R']
     bone = arm.edit_bones.new('hand.L')
     bone.head[:] = 0.6198, 0.0364, 1.4906
     bone.tail[:] = 0.6592, 0.0364, 1.4853
     bone.roll = -3.0065
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['forearm.L']
     bone = arm.edit_bones.new('hand.R')
     bone.head[:] = -0.6198, 0.0364, 1.4906
     bone.tail[:] = -0.6592, 0.0364, 1.4853
     bone.roll = 3.0065
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['forearm.R']
     bone = arm.edit_bones.new('palm.04.L')
     bone.head[:] = 0.6514, 0.0658, 1.4906
     bone.tail[:] = 0.7287, 0.0810, 1.4747
     bone.roll = -3.0715
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.L']
     bone = arm.edit_bones.new('palm.03.L')
     bone.head[:] = 0.6533, 0.0481, 1.4943
     bone.tail[:] = 0.7386, 0.0553, 1.4781
     bone.roll = -3.0290
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.L']
     bone = arm.edit_bones.new('palm.02.L')
     bone.head[:] = 0.6539, 0.0305, 1.4967
     bone.tail[:] = 0.7420, 0.0250, 1.4835
     bone.roll = -3.0669
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.L']
     bone = arm.edit_bones.new('palm.01.L')
     bone.head[:] = 0.6514, 0.0116, 1.4961
     bone.tail[:] = 0.7361, -0.0074, 1.4823
     bone.roll = -2.9422
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.L']
     bone = arm.edit_bones.new('thumb.01.L')
     bone.head[:] = 0.6380, -0.0005, 1.4848
     bone.tail[:] = 0.6757, -0.0408, 1.4538
     bone.roll = -0.7041
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.L']
     bone = arm.edit_bones.new('palm.04.R')
     bone.head[:] = -0.6514, 0.0658, 1.4906
     bone.tail[:] = -0.7287, 0.0810, 1.4747
     bone.roll = 3.0715
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.R']
     bone = arm.edit_bones.new('palm.03.R')
     bone.head[:] = -0.6533, 0.0481, 1.4943
     bone.tail[:] = -0.7386, 0.0553, 1.4781
     bone.roll = 3.0290
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.R']
     bone = arm.edit_bones.new('palm.02.R')
     bone.head[:] = -0.6539, 0.0305, 1.4967
     bone.tail[:] = -0.7420, 0.0250, 1.4835
     bone.roll = 3.0669
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.R']
     bone = arm.edit_bones.new('thumb.01.R')
     bone.head[:] = -0.6380, -0.0005, 1.4848
     bone.tail[:] = -0.6757, -0.0408, 1.4538
     bone.roll = 0.7041
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.R']
     bone = arm.edit_bones.new('palm.01.R')
     bone.head[:] = -0.6514, 0.0116, 1.4961
     bone.tail[:] = -0.7361, -0.0074, 1.4823
     bone.roll = 2.9332
-    bone.connected = False
+    bone.use_connect = False
     bone.parent = arm.edit_bones['hand.R']
     bone = arm.edit_bones.new('finger_pinky.01.L')
     bone.head[:] = 0.7287, 0.0810, 1.4747
     bone.tail[:] = 0.7698, 0.0947, 1.4635
     bone.roll = -3.0949
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.04.L']
     bone = arm.edit_bones.new('finger_ring.01.L')
     bone.head[:] = 0.7386, 0.0553, 1.4781
     bone.tail[:] = 0.7890, 0.0615, 1.4667
     bone.roll = -3.0081
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.03.L']
     bone = arm.edit_bones.new('finger_middle.01.L')
     bone.head[:] = 0.7420, 0.0250, 1.4835
     bone.tail[:] = 0.7975, 0.0221, 1.4712
     bone.roll = -2.9982
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.02.L']
     bone = arm.edit_bones.new('finger_index.01.L')
     bone.head[:] = 0.7361, -0.0074, 1.4823
     bone.tail[:] = 0.7843, -0.0204, 1.4718
     bone.roll = -3.0021
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.01.L']
     bone = arm.edit_bones.new('thumb.02.L')
     bone.head[:] = 0.6757, -0.0408, 1.4538
     bone.tail[:] = 0.6958, -0.0568, 1.4376
     bone.roll = -0.6963
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thumb.01.L']
     bone = arm.edit_bones.new('finger_pinky.01.R')
     bone.head[:] = -0.7287, 0.0810, 1.4747
     bone.tail[:] = -0.7698, 0.0947, 1.4635
     bone.roll = 3.0949
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.04.R']
     bone = arm.edit_bones.new('finger_ring.01.R')
     bone.head[:] = -0.7386, 0.0553, 1.4781
     bone.tail[:] = -0.7890, 0.0615, 1.4667
     bone.roll = 2.9892
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.03.R']
     bone = arm.edit_bones.new('finger_middle.01.R')
     bone.head[:] = -0.7420, 0.0250, 1.4835
     bone.tail[:] = -0.7975, 0.0221, 1.4712
     bone.roll = 2.9816
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.02.R']
     bone = arm.edit_bones.new('thumb.02.R')
     bone.head[:] = -0.6757, -0.0408, 1.4538
     bone.tail[:] = -0.6958, -0.0568, 1.4376
     bone.roll = 0.6963
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thumb.01.R']
     bone = arm.edit_bones.new('finger_index.01.R')
     bone.head[:] = -0.7361, -0.0074, 1.4823
     bone.tail[:] = -0.7843, -0.0204, 1.4718
     bone.roll = 2.9498
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['palm.01.R']
     bone = arm.edit_bones.new('finger_pinky.02.L')
     bone.head[:] = 0.7698, 0.0947, 1.4635
     bone.tail[:] = 0.7910, 0.1018, 1.4577
     bone.roll = -3.0949
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_pinky.01.L']
     bone = arm.edit_bones.new('finger_ring.02.L')
     bone.head[:] = 0.7890, 0.0615, 1.4667
     bone.tail[:] = 0.8177, 0.0650, 1.4600
     bone.roll = -3.0006
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_ring.01.L']
     bone = arm.edit_bones.new('finger_middle.02.L')
     bone.head[:] = 0.7975, 0.0221, 1.4712
     bone.tail[:] = 0.8289, 0.0206, 1.4643
     bone.roll = -2.9995
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_middle.01.L']
     bone = arm.edit_bones.new('finger_index.02.L')
     bone.head[:] = 0.7843, -0.0204, 1.4718
     bone.tail[:] = 0.8117, -0.0275, 1.4660
     bone.roll = -3.0064
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_index.01.L']
     bone = arm.edit_bones.new('thumb.03.L')
     bone.head[:] = 0.6958, -0.0568, 1.4376
     bone.tail[:] = 0.7196, -0.0671, 1.4210
     bone.roll = -0.8072
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thumb.02.L']
     bone = arm.edit_bones.new('finger_pinky.02.R')
     bone.head[:] = -0.7698, 0.0947, 1.4635
     bone.tail[:] = -0.7910, 0.1018, 1.4577
     bone.roll = 3.0949
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_pinky.01.R']
     bone = arm.edit_bones.new('finger_ring.02.R')
     bone.head[:] = -0.7890, 0.0615, 1.4667
     bone.tail[:] = -0.8177, 0.0650, 1.4600
     bone.roll = 3.0341
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_ring.01.R']
     bone = arm.edit_bones.new('finger_middle.02.R')
     bone.head[:] = -0.7975, 0.0221, 1.4712
     bone.tail[:] = -0.8289, 0.0206, 1.4643
     bone.roll = 3.0291
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_middle.01.R']
     bone = arm.edit_bones.new('thumb.03.R')
     bone.head[:] = -0.6958, -0.0568, 1.4376
     bone.tail[:] = -0.7196, -0.0671, 1.4210
     bone.roll = 0.8072
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['thumb.02.R']
     bone = arm.edit_bones.new('finger_index.02.R')
     bone.head[:] = -0.7843, -0.0204, 1.4718
     bone.tail[:] = -0.8117, -0.0275, 1.4660
     bone.roll = 3.0705
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_index.01.R']
     bone = arm.edit_bones.new('finger_pinky.03.L')
     bone.head[:] = 0.7910, 0.1018, 1.4577
     bone.tail[:] = 0.8109, 0.1085, 1.4523
     bone.roll = -3.0949
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_pinky.02.L']
     bone = arm.edit_bones.new('finger_ring.03.L')
     bone.head[:] = 0.8177, 0.0650, 1.4600
     bone.tail[:] = 0.8396, 0.0677, 1.4544
     bone.roll = -2.9819
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_ring.02.L']
     bone = arm.edit_bones.new('finger_middle.03.L')
     bone.head[:] = 0.8289, 0.0206, 1.4643
     bone.tail[:] = 0.8534, 0.0193, 1.4589
     bone.roll = -3.0004
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_middle.02.L']
     bone = arm.edit_bones.new('finger_index.03.L')
     bone.head[:] = 0.8117, -0.0275, 1.4660
     bone.tail[:] = 0.8331, -0.0333, 1.4615
     bone.roll = -3.0103
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_index.02.L']
     bone = arm.edit_bones.new('finger_pinky.03.R')
     bone.head[:] = -0.7910, 0.1018, 1.4577
     bone.tail[:] = -0.8109, 0.1085, 1.4523
     bone.roll = 3.0949
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_pinky.02.R']
     bone = arm.edit_bones.new('finger_ring.03.R')
     bone.head[:] = -0.8177, 0.0650, 1.4600
     bone.tail[:] = -0.8396, 0.0677, 1.4544
     bone.roll = 2.9819
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_ring.02.R']
     bone = arm.edit_bones.new('finger_middle.03.R')
     bone.head[:] = -0.8289, 0.0206, 1.4643
     bone.tail[:] = -0.8534, 0.0193, 1.4589
     bone.roll = 3.0004
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_middle.02.R']
     bone = arm.edit_bones.new('finger_index.03.R')
     bone.head[:] = -0.8117, -0.0275, 1.4660
     bone.tail[:] = -0.8331, -0.0333, 1.4615
     bone.roll = 2.9917
-    bone.connected = True
+    bone.use_connect = True
     bone.parent = arm.edit_bones['finger_index.02.R']
 
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -487,11 +487,11 @@ def metarig_template():
     pbone = obj.pose.bones['shoulder.L']
     pbone['type'] = 'copy'
     pbone = obj.pose.bones['shoulder.L']
-    pbone['copy.layer'] = 1
+    pbone['copy.layers'] = 1
     pbone = obj.pose.bones['shoulder.R']
     pbone['type'] = 'copy'
     pbone = obj.pose.bones['shoulder.R']
-    pbone['copy.layer'] = 1
+    pbone['copy.layers'] = 1
     pbone = obj.pose.bones['DLT-upper_arm.L']
     pbone['type'] = 'delta'
     pbone = obj.pose.bones['DLT-upper_arm.R']
@@ -515,7 +515,7 @@ def metarig_template():
     pbone = obj.pose.bones['palm.01.L']
     pbone['type'] = 'palm_curl'
     pbone = obj.pose.bones['palm.01.L']
-    pbone['palm_curl.layer'] = 5
+    pbone['palm_curl.layers'] = 5
     pbone = obj.pose.bones['thumb.01.L']
     pbone['type'] = 'finger_curl'
     pbone = obj.pose.bones['thumb.01.L']
@@ -531,7 +531,7 @@ def metarig_template():
     pbone = obj.pose.bones['palm.01.R']
     pbone['type'] = 'palm_curl'
     pbone = obj.pose.bones['palm.01.R']
-    pbone['palm_curl.layer'] = 5
+    pbone['palm_curl.layers'] = 5
     pbone = obj.pose.bones['finger_pinky.01.L']
     pbone['type'] = 'finger_curl'
     pbone = obj.pose.bones['finger_pinky.01.L']
index f91ee3ccc5adc5c8990494c99aa762817fa1fcf7..4345e8fcaee5f7bdc3eb02aff3e127a7e69407de 100644 (file)
@@ -65,7 +65,7 @@ class DATA_PT_skeleton(ArmatureButtonsPanel, bpy.types.Panel):
 
         col = split.column()
         col.label(text="Layers:")
-        col.prop(arm, "layer", text="")
+        col.prop(arm, "layers", text="")
         col.label(text="Protected Layers:")
         col.prop(arm, "layer_protection", text="")
 
index fea1c185ec9fdd51f02d4197a9d00cb16102a379..7b49148ebd85ee5f95590ccb1971d1ae3bf45036 100644 (file)
@@ -75,7 +75,7 @@ class BONE_PT_transform(BoneButtonsPanel, bpy.types.Panel):
             row = layout.row()
             col = row.column()
             col.prop(pchan, "location")
-            col.active = not (bone.parent and bone.connected)
+            col.active = not (bone.parent and bone.use_connect)
 
             col = row.column()
             if pchan.rotation_mode == 'QUATERNION':
@@ -111,7 +111,7 @@ class BONE_PT_transform_locks(BoneButtonsPanel, bpy.types.Panel):
         row = layout.row()
         col = row.column()
         col.prop(pchan, "lock_location")
-        col.active = not (bone.parent and bone.connected)
+        col.active = not (bone.parent and bone.use_connect)
 
         col = row.column()
         if pchan.rotation_mode in ('QUATERNION', 'AXIS_ANGLE'):
@@ -145,7 +145,7 @@ class BONE_PT_relations(BoneButtonsPanel, bpy.types.Panel):
 
         col = split.column()
         col.label(text="Layers:")
-        col.prop(bone, "layer", text="")
+        col.prop(bone, "layers", text="")
 
         col.separator()
 
@@ -162,12 +162,12 @@ class BONE_PT_relations(BoneButtonsPanel, bpy.types.Panel):
 
         sub = col.column()
         sub.active = (bone.parent is not None)
-        sub.prop(bone, "connected")
-        sub.prop(bone, "hinge", text="Inherit Rotation")
-        sub.prop(bone, "inherit_scale", text="Inherit Scale")
+        sub.prop(bone, "use_connect")
+        sub.prop(bone, "use_hinge", text="Inherit Rotation")
+        sub.prop(bone, "use_inherit_scale", text="Inherit Scale")
         sub = col.column()
-        sub.active = (not bone.parent or not bone.connected)
-        sub.prop(bone, "local_location", text="Local Location")
+        sub.active = (not bone.parent or not bone.use_connect)
+        sub.prop(bone, "use_local_location", text="Local Location")
 
 
 class BONE_PT_display(BoneButtonsPanel, bpy.types.Panel):
@@ -303,7 +303,7 @@ class BONE_PT_deform(BoneButtonsPanel, bpy.types.Panel):
         if not bone:
             bone = context.edit_bone
 
-        self.layout.prop(bone, "deform", text="")
+        self.layout.prop(bone, "use_deform", text="")
 
     def draw(self, context):
         layout = self.layout
@@ -313,7 +313,7 @@ class BONE_PT_deform(BoneButtonsPanel, bpy.types.Panel):
         if not bone:
             bone = context.edit_bone
 
-        layout.active = bone.deform
+        layout.active = bone.use_deform
 
         split = layout.split()
 
@@ -323,7 +323,7 @@ class BONE_PT_deform(BoneButtonsPanel, bpy.types.Panel):
         sub = col.column(align=True)
         sub.prop(bone, "envelope_distance", text="Distance")
         sub.prop(bone, "envelope_weight", text="Weight")
-        col.prop(bone, "multiply_vertexgroup_with_envelope", text="Multiply")
+        col.prop(bone, "use_envelope_multiply", text="Multiply")
 
         sub = col.column(align=True)
         sub.label(text="Radius:")
@@ -339,7 +339,7 @@ class BONE_PT_deform(BoneButtonsPanel, bpy.types.Panel):
         sub.prop(bone, "bbone_out", text="Ease Out")
 
         col.label(text="Offset:")
-        col.prop(bone, "cyclic_offset")
+        col.prop(bone, "use_cyclic_offset")
 
 
 class BONE_PT_custom_props(BoneButtonsPanel, PropertyPanel, bpy.types.Panel):
index 525a8be53e69f9e5cc4f174208eb742a6a8a98b3..3bbbb271bda399c02218ed3a3b85689ba8a5b483 100644 (file)
@@ -1578,7 +1578,7 @@ static int pose_armature_layers_invoke (bContext *C, wmOperator *op, wmEvent *ev
                
        /* get RNA pointer to armature data to use that to retrieve the layers as ints to init the operator */
        RNA_id_pointer_create((ID *)arm, &ptr);
-       RNA_boolean_get_array(&ptr, "layer", layers);
+       RNA_boolean_get_array(&ptr, "layers", layers);
        RNA_boolean_set_array(op->ptr, "layers", layers);
        
        /* part to sync with other similar operators... */
@@ -1598,7 +1598,7 @@ static int pose_armature_layers_exec (bContext *C, wmOperator *op)
        
        /* get pointer for armature, and write data there... */
        RNA_id_pointer_create((ID *)arm, &ptr);
-       RNA_boolean_set_array(&ptr, "layer", layers);
+       RNA_boolean_set_array(&ptr, "layers", layers);
        
        /* note, notifier might evolve */
        WM_event_add_notifier(C, NC_OBJECT|ND_POSE, ob);
@@ -1690,7 +1690,7 @@ static int pose_bone_layers_exec (bContext *C, wmOperator *op)
        {
                /* get pointer for pchan, and write flags this way */
                RNA_pointer_create((ID *)arm, &RNA_Bone, pchan->bone, &ptr);
-               RNA_boolean_set_array(&ptr, "layer", layers);
+               RNA_boolean_set_array(&ptr, "layers", layers);
        }
        CTX_DATA_END;
        
@@ -1764,7 +1764,7 @@ static int armature_bone_layers_exec (bContext *C, wmOperator *op)
        {
                /* get pointer for pchan, and write flags this way */
                RNA_pointer_create((ID *)arm, &RNA_EditBone, ebone, &ptr);
-               RNA_boolean_set_array(&ptr, "layer", layers);
+               RNA_boolean_set_array(&ptr, "layers", layers);
        }
        CTX_DATA_END;
        
index aa3b7f9422a2910db96a77d50151ac62629d741e..e60f9db79f61de6dc63de58af6a1d17949ad7119 100644 (file)
@@ -179,7 +179,7 @@ void ED_object_add_generic_props(wmOperatorType *ot, int do_editmode)
        RNA_def_float_vector(ot->srna, "location", 3, NULL, -FLT_MAX, FLT_MAX, "Location", "Location for the newly added object.", -FLT_MAX, FLT_MAX);
        RNA_def_float_rotation(ot->srna, "rotation", 3, NULL, -FLT_MAX, FLT_MAX, "Rotation", "Rotation for the newly added object", -FLT_MAX, FLT_MAX);
        
-       prop = RNA_def_boolean_layer_member(ot->srna, "layer", 20, NULL, "Layer", "");
+       prop = RNA_def_boolean_layer_member(ot->srna, "layers", 20, NULL, "Layer", "");
        RNA_def_property_flag(prop, PROP_HIDDEN);
 }
 
@@ -196,7 +196,7 @@ static void object_add_generic_invoke_options(bContext *C, wmOperator *op)
                RNA_float_set_array(op->ptr, "location", loc);
        }
         
-       if(!RNA_property_is_set(op->ptr, "layer")) {
+       if(!RNA_property_is_set(op->ptr, "layers")) {
                View3D *v3d = CTX_wm_view3d(C);
                Scene *scene = CTX_data_scene(C);
                int a, values[20], layer;
@@ -214,7 +214,7 @@ static void object_add_generic_invoke_options(bContext *C, wmOperator *op)
                                values[a]= (layer & (1<<a));
                }
                
-               RNA_boolean_set_array(op->ptr, "layer", values);
+               RNA_boolean_set_array(op->ptr, "layers", values);
        }
 }
 
@@ -235,8 +235,8 @@ int ED_object_add_generic_get_opts(bContext *C, wmOperator *op, float *loc, floa
                *enter_editmode = TRUE;
        }
 
-       if(RNA_property_is_set(op->ptr, "layer")) {
-               RNA_boolean_get_array(op->ptr, "layer", layer_values);
+       if(RNA_property_is_set(op->ptr, "layers")) {
+               RNA_boolean_get_array(op->ptr, "layers", layer_values);
                *layer= 0;
                for(a=0; a<20; a++) {
                        if(layer_values[a])
index 6e9244e39cab69f652e9a5056c5a7e59e4899dde..b8eebd161dc81c6dde9bd36752f6f42f903b5e30 100644 (file)
@@ -1032,7 +1032,7 @@ static unsigned int move_to_layer_init(bContext *C, wmOperator *op)
        int values[20], a;
        unsigned int lay= 0;
 
-       if(!RNA_property_is_set(op->ptr, "layer")) {
+       if(!RNA_property_is_set(op->ptr, "layers")) {
                CTX_DATA_BEGIN(C, Base*, base, selected_editable_bases) {
                        lay |= base->lay;
                }
@@ -1041,10 +1041,10 @@ static unsigned int move_to_layer_init(bContext *C, wmOperator *op)
                for(a=0; a<20; a++)
                        values[a]= (lay & (1<<a));
                
-               RNA_boolean_set_array(op->ptr, "layer", values);
+               RNA_boolean_set_array(op->ptr, "layers", values);
        }
        else {
-               RNA_boolean_get_array(op->ptr, "layer", values);
+               RNA_boolean_get_array(op->ptr, "layers", values);
 
                for(a=0; a<20; a++)
                        if(values[a])
@@ -1130,7 +1130,7 @@ void OBJECT_OT_move_to_layer(wmOperatorType *ot)
        ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* properties */
-       RNA_def_boolean_layer_member(ot->srna, "layer", 20, NULL, "Layer", "");
+       RNA_def_boolean_layer_member(ot->srna, "layers", 20, NULL, "Layer", "");
 }
 
 /************************** Link to Scene Operator *****************************/
index accdb67fb991d3046a937bfd4fe592710c2bac63..fa9a97f4e74734816e18a97de996b07d147d5a87 100644 (file)
@@ -635,7 +635,7 @@ static int object_select_by_layer_exec(bContext *C, wmOperator *op)
        short extend;
        
        extend= RNA_boolean_get(op->ptr, "extend");
-       layernum = RNA_int_get(op->ptr, "layer");
+       layernum = RNA_int_get(op->ptr, "layers");
        
        if (extend == 0) {
                CTX_DATA_BEGIN(C, Base*, base, visible_bases) {
@@ -673,7 +673,7 @@ void OBJECT_OT_select_by_layer(wmOperatorType *ot)
        
        /* properties */
        RNA_def_boolean(ot->srna, "extend", FALSE, "Extend", "Extend selection instead of deselecting everything first.");
-       RNA_def_int(ot->srna, "layer", 1, 1, 20, "Layer", "", 1, 20);
+       RNA_def_int(ot->srna, "layers", 1, 1, 20, "Layer", "", 1, 20);
 }
 
 /************************** Select Inverse *************************/
index f4f9fc0844c8001b30229eb0d3290ae6f1af36ad..3217e73e3fbf5f6646979d9ab851ac5dc698c5d0 100644 (file)
@@ -393,7 +393,7 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
 
        /* flags */
-       prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_LAYER_MEMBER);
+       prop= RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
        RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
        RNA_def_property_array(prop, 32);
        if(editbone) RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_layer_set");
@@ -401,34 +401,34 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
        RNA_def_property_ui_text(prop, "Layers", "Layers bone exists in");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
 
-       prop= RNA_def_property(srna, "connected", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_connect", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_CONNECTED);
        if(editbone) RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_connected_set");
        else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Connected", "When bone has a parent, bone's head is struck to the parent's tail");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "hinge", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_hinge", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_HINGE);
        RNA_def_property_ui_text(prop, "Inherit Rotation", "Bone inherits rotation or scale from parent bone");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "multiply_vertexgroup_with_envelope", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_envelope_multiply", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_MULT_VG_ENV);
        RNA_def_property_ui_text(prop, "Multiply Vertex Group with Envelope", "When deforming bone, multiply effects of Vertex Group weights with Envelope influence");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "deform", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_deform", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_DEFORM);
        RNA_def_property_ui_text(prop, "Deform", "Bone does not deform any geometry");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       prop= RNA_def_property(srna, "inherit_scale", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_inherit_scale", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_ui_text(prop, "Inherit Scale", "Bone inherits scaling from parent bone");
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_SCALE);
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
 
-       prop= RNA_def_property(srna, "local_location", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_local_location", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_ui_text(prop, "Local Location", "Bone location is set in local space");
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_LOCAL_LOCATION);
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
@@ -438,7 +438,7 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
        RNA_def_property_ui_text(prop, "Draw Wire", "Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
        
-       prop= RNA_def_property(srna, "cyclic_offset", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_cyclic_offset", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_CYCLICOFFSET);
        RNA_def_property_ui_text(prop, "Cyclic Offset", "When bone doesn't have a parent, it receives cyclic offset effects");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
@@ -782,7 +782,7 @@ static void rna_def_armature(BlenderRNA *brna)
 
        /* Boolean values */
                /* layer */
-       prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_LAYER_MEMBER);
+       prop= RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
        RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
        RNA_def_property_array(prop, 32);
        RNA_def_property_ui_text(prop, "Visible Layers", "Armature layer visibility");
index 6fa34ddcc4f3cef276cd931e80dce1c245cd1ced..aac76177f5b0bedb9d8e37f65ba41dbeb852f47e 100644 (file)
@@ -219,14 +219,14 @@ static void rna_def_text(BlenderRNA *brna)
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Current Character", "Index of current character in current line, and also start index of character in selection if one exists");
        
-       prop= RNA_def_property(srna, "selection_end_line", PROP_POINTER, PROP_NONE);
+       prop= RNA_def_property(srna, "select_end_line", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_pointer_sdna(prop, NULL, "sell");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_struct_type(prop, "TextLine");
        RNA_def_property_ui_text(prop, "Selection End Line", "End line of selection");
        
-       prop= RNA_def_property(srna, "selection_end_character", PROP_INT, PROP_UNSIGNED);
+       prop= RNA_def_property(srna, "select_end_character", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "selc");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Selection End Character", "Index of character after end of selection in the selection end line");
index ce575d0bd7348c0a1a138dd382cda8a0a26904e0..ac3ed5ca38345cf4a2708131446f44e6d52590fd 100644 (file)
 #+ * Bone.head_radius -> head_radius:   float  "Radius of head of bone (for Envelope deform only)"
 #+ * Bone.hide -> hide:   boolean  "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)"
 #+ * Bone.hide_select -> hide_select:   boolean  "Bone is able to be selected"
- + * Bone.layer -> layers:   boolean[32]  "Layers bone exists in"
+#Bone.layers -> layers:   boolean[32]  "Layers bone exists in"
 #+ * Bone.matrix -> matrix:   float[9]  "3x3 bone matrix"
 #+ * Bone.matrix_local -> matrix_local:   float[16]  "4x4 bone matrix relative to armature"
 #+ * Bone.name -> name:   string  "NO DESCRIPTION"
 #+ * Bone.tail -> tail:   float[3]  "Location of tail end of the bone"
 #+ * Bone.tail_local -> tail_local:   float[3]  "Location of tail end of the bone relative to armature"
 #+ * Bone.tail_radius -> tail_radius:   float  "Radius of tail of bone (for Envelope deform only)"
- + * Bone.connected -> use_connect:   boolean,  "(read-only)    When bone has a parent, bones head is struck to the parents tail"
- + * Bone.cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesnt have a parent, it receives cyclic offset effects"
- + * Bone.deform -> use_deform:   boolean  "Bone does not deform any geometry"
- + * Bone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:   boolean  "When deforming bone, multiply effects of Vertex Group weights with Envelope influence"
- + * Bone.hinge -> use_hinge:   boolean  "Bone inherits rotation or scale from parent bone"
- + * Bone.inherit_scale -> use_inherit_scale:   boolean  "Bone inherits scaling from parent bone"
- + * Bone.local_location -> use_local_location:   boolean  "Bone location is set in local space"
+#Bone.use_connect -> use_connect:   boolean,  "(read-only)    When bone has a parent, bones head is struck to the parents tail"
+#Bone.use_cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesnt have a parent, it receives cyclic offset effects"
+#Bone.use_deform -> use_deform:   boolean  "Bone does not deform any geometry"
+#Bone.use_envelope_multiply -> use_envelope_multiply:   boolean  "When deforming bone, multiply effects of Vertex Group weights with Envelope influence"
+#Bone.use_hinge -> use_hinge:   boolean  "Bone inherits rotation or scale from parent bone"
+#Bone.use_inherit_scale -> use_inherit_scale:   boolean  "Bone inherits scaling from parent bone"
+#Bone.use_local_location -> use_local_location:   boolean  "Bone location is set in local space"
 #+ * BoneGroup.color_set -> color_set:   enum  "Custom color set to use"
 #+ * BoneGroup.colors -> colors:   pointer,  "(read-only)    Copy of the colors associated with the groups color set"
 #+ * BoneGroup.name -> name:   string  "NO DESCRIPTION"
 #+ * EditBone.head_radius -> head_radius:   float  "Radius of head of bone (for Envelope deform only)"
 #+ * EditBone.hide -> hide:   boolean  "Bone is not visible when in Edit Mode"
 #+ * EditBone.hide_select -> hide_select:   boolean  "Bone is able to be selected"
- + * EditBone.layer -> layers:   boolean[32]  "Layers bone exists in"
+#EditBone.layers -> layers:   boolean[32]  "Layers bone exists in"
 #+ * EditBone.lock -> lock:   boolean  "Bone is not able to be transformed when in Edit Mode"
 #+ * EditBone.matrix -> matrix:   float[16],  "(read-only)    Read-only matrix calculated from the roll (armature space)"
 #+ * EditBone.name -> name:   string  "NO DESCRIPTION"
 #EditBone.show_wire -> show_wire:   boolean  "Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes"
 #+ * EditBone.tail -> tail:   float[3]  "Location of tail end of the bone"
 #+ * EditBone.tail_radius -> tail_radius:   float  "Radius of tail of bone (for Envelope deform only)"
- + * EditBone.connected -> use_connect:   boolean  "When bone has a parent, bones head is struck to the parents tail"
- + * EditBone.cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesnt have a parent, it receives cyclic offset effects"
- + * EditBone.deform -> use_deform:   boolean  "Bone does not deform any geometry"
- + * EditBone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:   boolean  "When deforming bone, multiply effects of Vertex Group weights with Envelope influence"
- + * EditBone.hinge -> use_hinge:   boolean  "Bone inherits rotation or scale from parent bone"
- + * EditBone.inherit_scale -> use_inherit_scale:   boolean  "Bone inherits scaling from parent bone"
- + * EditBone.local_location -> use_local_location:   boolean  "Bone location is set in local space"
+#EditBone.use_connect -> use_connect:   boolean  "When bone has a parent, bones head is struck to the parents tail"
+#EditBone.use_cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesnt have a parent, it receives cyclic offset effects"
+#EditBone.use_deform -> use_deform:   boolean  "Bone does not deform any geometry"
+#EditBone.use_envelope_multiply -> use_envelope_multiply:   boolean  "When deforming bone, multiply effects of Vertex Group weights with Envelope influence"
+#EditBone.use_hinge -> use_hinge:   boolean  "Bone inherits rotation or scale from parent bone"
+#EditBone.use_inherit_scale -> use_inherit_scale:   boolean  "Bone inherits scaling from parent bone"
+#EditBone.use_local_location -> use_local_location:   boolean  "Bone location is set in local space"
 #+ * EffectorWeights.all -> all:   float  "All effectors weight"
  + * EffectorWeights.do_growing_hair -> apply_to_hair_growing:   boolean  "Use force fields when growing hair"
 #+ * EffectorWeights.boid -> boid:   float  "Boid effector weight"
 #+ * ID|Armature.ghost_size -> ghost_size:   int  "Frame step for Ghosts (not for On Keyframes Onion-skinning method)"
 #+ * ID|Armature.ghost_step -> ghost_step:   int  "Number of frame steps on either side of current frame to show as ghosts (only for Around Current Frame Onion-skinning method)"
 #+ * ID|Armature.ghost_type -> ghost_type:   enum  "Method of Onion-skinning for active Action"
- + * ID|Armature.layer -> layers:   boolean[32]  "Armature layer visibility"
+#ID|Armature.layers -> layers:   boolean[32]  "Armature layer visibility"
  + * ID|Armature.layer_protection -> layers_protected:   boolean[32]  "Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo"
 #+ * ID|Armature.pose_position -> pose_position:   enum  "Show armature in binding pose or final posed state"
 #ID|Armature.show_axes -> show_axes:   boolean  "Draw bone axes"
 #ID|Text.is_modified -> is_modified:   boolean,  "(read-only)    Text file on disk is different than the one in memory"
 #+ * ID|Text.lines -> lines:   collection,  "(read-only)    Lines of text"
 #+ * ID|Text.markers -> markers:   collection,  "(read-only)    Text markers highlighting part of the text"
- + * ID|Text.selection_end_character -> select_end_character:   int,  "(read-only)    Index of character after end of selection in the selection end line"
- + * ID|Text.selection_end_line -> select_end_line:   pointer,  "(read-only)    End line of selection"
+#ID|Text.select_end_character -> select_end_character:   int,  "(read-only)    Index of character after end of selection in the selection end line"
+#ID|Text.select_end_line -> select_end_line:   pointer,  "(read-only)    End line of selection"
 #+ * ID|Text.use_module -> use_module:   boolean  "Register this text as a module on loading, Text name must end with .py"
 #ID|Text.use_tabs_as_spaces -> use_tabs_as_spaces:   boolean  "Automatically converts all new tabs into spaces"
 #+ * ID|Texture.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
  + * WorldStarsSettings.color_randomization -> color_random:   float  "Randomize star colors"
  + * WorldStarsSettings.min_distance -> distance_min:   float  "Minimum distance to the camera for stars"
 #+ * WorldStarsSettings.size -> size:   float  "Average screen dimension of stars"
-#+ * WorldStarsSettings.use_stars -> use_stars:   boolean  "Enable starfield generation[651157 refs]"
+#+ * WorldStarsSettings.use_stars -> use_stars:   boolean  "Enable starfield generation[651149 refs]"