import bpy
import bmesh
import math as m
import fnmatch
character = "MyCharacter"
rig = f"{character}_Armature"
origin = (0,0,0)
emplist = bpy.data.collections['EmptyCollection'].all_objects
###############################################
#### Bone heirarchy construction functions ####
###############################################
def findEmpty(e):
for em in emplist:
if em.name == e:
return em.location
def SelectReturn(b):
for bone in Armature.data.edit_bones:
if fnmatch.fnmatchcase(bone.name, b):
return bone
def SelectListReturn(*args):
blist = []
for bone in Armature.data.edit_bones:
for a in args:
if fnmatch.fnmatchcase(bone.name, a):
blist.append(bone)
return blist
def SelectSymmetrize():
for bone in Armature.data.edit_bones:
if fnmatch.fnmatchcase(bone.name, '*l'):
bone.select = True
bone.select_head = True
bone.select_tail = True
bpy.ops.armature.symmetrize()
def AddConstraint(con, activeBone, subtar, polsubtar=None, limitcon=None, PHY_tar=None, COLL_tar=None):
## Keyword args (**kwargs) are checks. Different constraints have different data fields that need to be filled.
## if any of the **kwargs are true (not None) then the if conditionals will redirect the process to meet the
## needs of that constraint.
## Or.... I could just break these functions (methods in python) into different function for each use case
if limitcon != None:
if limitcon == 'LOC':
pbone = bpy.context.object.pose.bones[activeBone]
constraint = pbone.constraints.new(con)
elif limitcon == 'ROT':
pbone = bpy.context.object.pose.bones[activeBone]
constraint = pbone.constraints.new(con)
else:
pbone = bpy.context.object.pose.bones[activeBone]
if COLL_tar != None:
target = bpy.data.objects[COLL_tar]
subtarget = bpy.data.objects[COLL_tar].vertex_groups[subtar]
elif PHY_tar != None:
target = bpy.data.objects[PHY_tar]
subtarget = bpy.data.objects[PHY_tar].vertex_groups[subtar]
else:
target = bpy.context.scene.objects.get(rig)
subtarget = bpy.context.scene.objects.get(rig).pose.bones.get(subtar)
constraint = pbone.constraints.new(con)
constraint.target = target
constraint.subtarget = subtarget.name
if polsubtar != None:
poletarget = bpy.context.scene.objects.get(rig)
polesubtarget = bpy.context.scene.objects.get(rig).pose.bones.get(polsubtar)
constraint.pole_target = poletarget
constraint.pole_subtarget = polsubtar
return constraint
### def SymmetrizeConstraints() - I refactored from someone elses code I found on stackoverflow or one of those sites
### there's no point spending hours re-inventing the wheel when someone else already did it, and posted it.
### HINT, HINT...
def SymmetrizeConstraints():
copyFrom = "l"
pBones = [ b for b in bpy.context.object.pose.bones if b.name[-2:] == "_%s" % copyFrom ]
for b in pBones:
for c in b.constraints:
otherSide = "r" if copyFrom == "l" else "l"
otherBone = bpy.context.object.pose.bones[
b.name.replace( "_%s" % copyFrom, "_%s" % otherSide )
]
nc = otherBone.constraints.new( c.type )
for prop in dir( c ):
# This is fairly ugly and dirty, but quick and does the trick...
try:
constrProp = getattr( c, prop )
if type( constrProp ) == type(str()) and constrProp[-2:] in ["_l", "_r"]:
# Replace string property values from L to R and vice versa
oppositeVal = constrProp.replace("_l", "_r") if constrProp[-2:] == "_l" else constrProp.replace("_r", "_l")
setattr( nc, prop, oppositeVal )
elif 'max_' in prop and 'LIMIT_LOCATION' not in c.type:
setattr( nc, prop, getattr( c, prop.replace( 'max', 'min' ) ) * -1 )
elif 'min_' in prop and 'LIMIT_LOCATION' not in c.type:
setattr( nc, prop, getattr( c, prop.replace( 'min', 'max' ) ) * -1 )
elif prop == 'influence':
# Influence 0 becomes 1 and 1 becomes 0
setattr( nc, prop, abs( constrProp) )
elif prop == 'distance':
# distance stays the same
setattr( nc, prop, constrProp )
elif prop == 'rest_length':
# Copy original length
setattr( nc, prop, constrProp )
elif prop == 'head_tail':
# Copy original length
setattr( nc, prop, constrProp )
elif prop == 'chain_count':
# Copy original length
setattr( nc, prop, constrProp )
elif prop == 'iterations':
# Copy original length
setattr( nc, prop, constrProp )
elif prop == 'weight':
# Copy original length
setattr( nc, prop, constrProp )
elif type( constrProp ) in [ type( float() ), type( int() ) ] and prop != 'pole_angle' and c.type != 'LIMIT_LOCATION':
# Invert float and int values ( mult by -1 )
setattr( nc, prop, constrProp * -1 )
elif prop == 'pole_angle':
# invert original in degrees
if constrProp==m.radians(180):
setattr( nc, prop, m.radians(0))
elif constrProp==m.radians(0):
setattr( nc, prop, m.radians(180))
else:
# Copy all other values as they are
setattr( nc, prop, constrProp )
except:
pass
def constraintFix(bone, const, prop, value):
code = f"bpy.context.object.pose.bones['{bone}'].constraints['{const}'].{prop} = {value}"
exec(code)
##################################
#### Driver Linking Functions ####
##################################
## bone:bone the driver is on, drivenChannel:property channel to drive, tarBone:driving obj or bone
## tarChannel:driving channel on tarbone, space:coordinate space, exp:driver expression,
## custVar:custom driver var(ex. Distance), varCount:number of non-custom variables,
## package:string path to constraint property to add driver, channelIndex:vector channel (xyz) to add driver..if needed
## vtype:driver variable type, dtype:Driver type (first drop down menu in driver editor)
def AddDriver(bone, drivenChannel, tarBone, tarChannel, space, exp, custVar=[], varCount=1,\
package=None, channelIndex=-1, vtype='TRANSFORMS', dtype='SCRIPTED'):
if package!=None:
con = bpy.data.objects[rig]
driv = con.driver_add(package)
driv.driver.type = dtype
driv.driver.expression = exp
else:
driv = bpy.data.objects[rig].pose.bones[bone].driver_add(drivenChannel, channelIndex)
driv.driver.type = dtype
driv.driver.expression = exp
if varCount>1:
for v in range(varCount):
var = driv.driver.variables.new()
var.name = 'var'+str(v)
var.type = vtype
var.targets[0].id = bpy.data.objects[rig]
var.targets[0].bone_target = tarBone[v]
var.targets[0].transform_type = tarChannel[v]
var.targets[0].transform_space = space[v]
elif varCount==1:
var = driv.driver.variables.new()
var.name = 'var0'
var.type = vtype
var.targets[0].id = bpy.data.objects[rig]
var.targets[0].bone_target = tarBone
var.targets[0].transform_type = tarChannel
var.targets[0].transform_space = space
else:
pass
if custVar != []:
if len(custVar)==5:
var = driv.driver.variables.new()
var.name = 'var'+str(len(driv.driver.variables)-1)
var.type = custVar[0]
var.targets[0].id = bpy.data.objects[rig]
var.targets[0].bone_target = custVar[1]
var.targets[0].transform_space = custVar[2]
var.targets[1].id = bpy.data.objects[rig]
var.targets[1].bone_target = custVar[3]
var.targets[1].transform_space = custVar[4]
elif len(custVar)==3:
var = driv.driver.variables.new()
var.name = 'var'+str(len(driv.driver.variables)-1)
var.type = custVar[0]
var.targets[0].id = bpy.data.objects[rig]
var.targets[0].bone_target = custVar[1]
var.targets[1].id = bpy.data.objects[rig]
var.targets[1].bone_target = custVar[2]
else:
pass
return driv
def AddPropertyDriver(bone, drivenChannel, tarId, tarDataPath, exp,\
varCount=1, package=None, channelIndex=-1, vtype='SINGLE_PROP', dtype='SCRIPTED'):
if package!=None:
con = bpy.data.objects[rig]
driv = con.driver_add(package)
driv.driver.type = dtype
driv.driver.expression = exp
else:
driv = bpy.data.objects[rig].pose.bones[bone].driver_add(drivenChannel, channelIndex)
driv.driver.type = dtype
driv.driver.expression = exp
if varCount>1:
for v in range(varCount):
var = driv.driver.variables.new()
var.name = 'var'+str(v)
var.type = vtype
var.targets[v].id = bpy.data.objects[tarId[v]]
var.targets[v].data_path = tarDataPath[v]
else:
var = driv.driver.variables.new()
var.name = 'var'
var.type = vtype
var.targets[0].id = bpy.data.objects[tarId]
var.targets[0].data_path = tarDataPath
return driv
def Add_PHY_PropertyDriver(mesh, mod, prop, tarId, tarDataPath, vtype='SINGLE_PROP', dtype='AVERAGE'):
package = f'modifiers["{mod}"].settings.{prop}'
con = bpy.data.objects[mesh]
driv = con.driver_add(package)
driv.driver.type = dtype
var = driv.driver.variables.new()
var.name = 'var'
var.type = vtype
var.targets[0].id = bpy.data.objects[tarId]
var.targets[0].data_path = tarDataPath
return driv
############################################
########## Bone Physics Functions ##########
############################################
### months later after not looking at this code... I really should have commented this function more, really...
def add_Physics(parbone, PHYgroup):
bpy.context.scene.cursor.location = (0,0,0)
parentBoneLOC = bpy.data.objects[rig].matrix_world @ \
bpy.data.objects[rig].pose.bones[parbone].matrix.to_translation() ## get the world space location in ref. to parent bone
bpy.ops.mesh.primitive_cube_add(enter_editmode=True) ## create a primitive cube
PHy_mesh = 'PHY_mesh_'+ parbone ## save string name of current physics group to a var
bpy.context.active_object.name = PHy_mesh ## name the primitive cube as mesh of physics group
mesh = bmesh.from_edit_mesh(bpy.context.object.data) ## turn primitive cube to bmesh object
if mesh.select_mode != 'VERT':
bpy.ops.mesh.select_mode(type='VERT') ## switch to vertex mode of cube, now bmesh obj
bpy.ops.mesh.select_all(action='SELECT') ## select all verts of cube
bpy.ops.mesh.merge(type='CENTER') ## colapse/merge all verts down to one
bonelist = [] ## create empty list
mesh.verts.ensure_lookup_table() ## ensure the vert lookup table is up to date? read that you should do this frequent working with bmesh
for bone in bpy.data.objects[rig].pose.bones: ## loop thru all the pose bones of the rig and append() all bones of this physics group to
if PHYgroup in bone.name: ## the empty list you created
bonelist.append(bone.name)
fm = bpy.data.objects[rig].matrix_world @ bpy.data.objects[rig].pose.bones[bonelist[0]].matrix ## get worldspace location of first bone in list
fm = fm.to_translation() ## previous line converts localspace to worldspace....this function converts matrix coordinates to vector...
mesh.verts.ensure_lookup_table()
mesh.verts[0].co = fm ## relocate your single vert of mesh (simulation obj) to that bone, just the vert, not the obj
bpy.ops.object.vertex_group_add() ## create a new vertex group for this sim obj
bpy.context.object.vertex_groups.active.name = 'Vgrp_' + bonelist[0] ## name vertex group
bpy.ops.object.vertex_group_assign() ## assign single vert to vertex group
if len(bonelist) > 1: ## ok, this loop goes thru all the physic bones in our list, duplicates the sim obj *Vert*, now 1 obj 2 verts
for i in range(1, len(bonelist)): ## and so on for each iteration of the loop, removes the new vert from it's original vertex group and
mesh.verts.ensure_lookup_table() ## creates a new one, relocates new vert to the current bone being processed in the loop
mesh.verts[i-1].select_set(True) ## and loop thru again til done
bpy.ops.mesh.duplicate_move(MESH_OT_duplicate={"mode":1},\
TRANSFORM_OT_translate={"value":(0, 0, 0), "orient_axis_ortho":'X',\
"orient_type":'GLOBAL', "orient_matrix":((0, 0, 0), (0, 0, 0), (0, 0, 0)),\
"orient_matrix_type":'GLOBAL', "constraint_axis":(False, False, False),\
"mirror":False, "use_proportional_edit":False, "proportional_edit_falloff":'SMOOTH',\
"proportional_size":1, "use_proportional_connected":False, "use_proportional_projected":False,\
"snap":False, "snap_target":'CLOSEST', "snap_point":(0, 0, 0), "snap_align":False,\
"snap_normal":(0, 0, 0), "gpencil_strokes":False, "cursor_transform":False, "texture_space":False,\
"remove_on_cancel":False, "view2d_edge_pan":False, "release_confirm":False, "use_accurate":False,\
"use_automerge_and_split":False})
for v in mesh.verts:
v.select_set(False)
mesh.verts.ensure_lookup_table()
mesh.verts[i].select_set(True)
bpy.ops.object.vertex_group_remove_from()
bpy.ops.object.vertex_group_add()
bpy.context.object.vertex_groups.active.name = 'Vgrp_' + bonelist[i]
bpy.ops.object.vertex_group_assign()
fm = bpy.data.objects[rig].matrix_world\
@ bpy.data.objects[rig].pose.bones[bonelist[i]].matrix
fm = fm.to_translation()
mesh.verts.ensure_lookup_table()
mesh.verts[i].co = fm
bpy.ops.object.mode_set(mode='OBJECT') ## get out of edit mode, back to object
bpy.context.scene.cursor.location = parentBoneLOC ## move the 3d cursor to the parent bone of the physics bones hierarchy
bpy.ops.object.origin_set(type='ORIGIN_CURSOR') ## Set the origin of the sim obj to the location of parent bone
bpy.ops.object.select_all(action='DESELECT') ## deselect all
bpy.data.objects[PHy_mesh].select_set(True) ## select the simulation mesh
bpy.ops.object.modifier_add(type='SOFT_BODY') ## add a softbody modifier
bpy.data.objects[PHy_mesh].modifiers["Softbody"].settings.friction = 13 ## change friction settings
bpy.data.objects[PHy_mesh].modifiers["Softbody"].settings.mass = .2 ## ## change mass settings
bpy.ops.object.select_all(action='DESELECT') ## deselect all
bpy.data.objects[rig].select_set(True) ## select the rig object
bpy.context.view_layer.objects.active = bpy.data.objects[rig] ## make the rig object the active object
bpy.ops.object.mode_set(mode='POSE') ## switch to pose mode
for bone in bonelist: ## matching names and adding constraints to main and aim bones of current physics group
if fnmatch.fnmatchcase(bone, '*MAIN_l'):
for bon in bonelist:
if fnmatch.fnmatchcase(bon, '*AIM_l'):
boneVarDamp = AddConstraint('DAMPED_TRACK', bone, bon)
boneVarDamp.name = 'PHY_DAMP_' + bone
boneVarDamp.head_tail = 0
boneVarDamp.track_axis = 'TRACK_Y'
boneVarDamp.influence = 1
if fnmatch.fnmatchcase(bone, '*MAIN_r'):
for bon in bonelist:
if fnmatch.fnmatchcase(bon, '*AIM_r'):
boneVarDamp = AddConstraint('DAMPED_TRACK', bone, bon)
boneVarDamp.name = 'PHY_DAMP_' + bone
boneVarDamp.head_tail = 0
boneVarDamp.track_axis = 'TRACK_Y'
boneVarDamp.influence = 1
## copy location constraint of physics bone to sim mesh vert at its location
## so physics bones are following their respective vert via custom vertex groups we made for each vert
## and each vert is effected by softbody dynamics.... In short "makes things shake and jiggle with motion"
## other constraints keep the motion of the physics within realistic ranges
boneVarloc = AddConstraint('COPY_LOCATION', bone, 'Vgrp_' + bone, PHY_tar= PHy_mesh)
boneVarloc.name = 'PHY_LOC_' + bone
boneVarloc.use_x = True
boneVarloc.use_y = True
boneVarloc.use_z = True
boneVarloc.use_offset = False
boneVarloc.target_space = 'WORLD'
boneVarloc.owner_space = 'WORLD'
if 'MAIN_' in bone:
boneVarloc.influence = .7
else:
boneVarloc.influence = 1
boneVarLim = AddConstraint('LIMIT_LOCATION', bone, '', limitcon='LOC')
boneVarLim.name = 'PHY_LIM_' + bone
if 'AIM_' in bone:
param = {'min':[-.05,-.05,-.05], 'max':[.05,.05,.05]}
else:
param = {'min':[-.03,-.03,-.03], 'max':[.03,.03,.03]}
x, y, z = 0,1,2
for end in ['min','max']:
for ax in ['x','y','z']:
code = f"boneVarLim.use_{end}_{ax} = True\nboneVarLim.{end}_{ax} = {param.get(end)[eval(ax)]}"
exec(code)
### for some operations in bpy module you have to concatenate code into a string and run it thru an exec() function
### I don't know why, you just do...
### eval() takes a string literal and finds the corresponding variable with scope 'x' -> x -> which equals 0
boneVarLim.owner_space = 'LOCAL'
boneVarLim.influence = 1
bpy.ops.object.mode_set(mode='OBJECT', toggle=False) ## get out of edit mode, back to object
bpy.ops.object.select_all(action='DESELECT') ## deselect all
bpy.data.objects[rig].select_set(True) ## select the rig object
bpy.context.view_layer.objects.active = bpy.data.objects[rig] ## make the rig object the active object
bpy.ops.object.mode_set(mode='POSE') ## go to pose mode.....all this is just parenting the sim obj/mesh to the main bone
bpy.context.object.pose.bones[parbone].bone.select = True ## that was passed as the arg 'parbone' to this function
bpy.context.object.data.bones.active = bpy.context.object.pose.bones[parbone].bone
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects[PHy_mesh].select_set(True)
bpy.data.objects[rig].select_set(True)
bpy.ops.object.parent_set(type='BONE', keep_transform=True)
### ALWAYS COMMENT YOUR CODE!!
#################################
############# Setup #############
#################################
#Set the Cursor to the world origin
bpy.context.scene.cursor.location = 0,0,0
#create an armature
bpy.ops.object.armature_add( enter_editmode=False )
#rename armature
bpy.data.objects['Armature'].name = rig
#assign armature object to variable
Armature = bpy.data.objects[rig]
ArmatureOps = bpy.ops.object
ArmEdit = Armature.data.edit_bones
ArmBones = Armature.data.bones
ArmPose = Armature.pose.bones
ArmContx = bpy.context.object
#select the armature
Armature.select_set(True)
#switch to editmode
ArmatureOps.mode_set(mode='EDIT', toggle=False)
#change bone viewport display type
bpy.data.armatures[bpy.context.object.data.name].display_type = 'STICK'
#delete default bone
ArmEdit.remove(ArmEdit[0])
############################################
############## BUILD SKELETON ##############
############################################
#add root
root = ArmContx.data.edit_bones.new('root')
root.head = origin
root.tail = (0,1,0)
#add gravity_ROOT
gravity_ROOT = ArmContx.data.edit_bones.new('gravity_ROOT')
gravity_ROOT.head = origin
gravity_ROOT.tail = findEmpty('gravity_ROOT_tail')
gravity_ROOT.roll = m.radians(0)
#add gravity_AIM
gravity_AIM = ArmContx.data.edit_bones.new('gravity_AIM')
gravity_AIM.head = findEmpty('gravity_AIM_head')
gravity_AIM.tail = findEmpty('gravity_AIM_tail')
gravity_AIM.roll = m.radians(0)
Armature.data.edit_bones['gravity_AIM'].parent = Armature.data.edit_bones['gravity_ROOT']
Armature.data.edit_bones['gravity_AIM'].use_connect = False
#add PROPERTIES
PROPERTIES = ArmContx.data.edit_bones.new('PROPERTIES')
PROPERTIES.head = findEmpty('PROPERTIES_head')
PROPERTIES.tail = findEmpty('PROPERTIES_tail')
PROPERTIES.roll = m.radians(89)
Armature.data.edit_bones['PROPERTIES'].parent = Armature.data.edit_bones['root']
Armature.data.edit_bones['PROPERTIES'].use_connect = False
#add pelvis
pelvis = ArmContx.data.edit_bones.new('pelvis')
pelvis.head = findEmpty('pelvis_head')
pelvis.tail = findEmpty('spine_01_head')
pelvis.roll = m.radians(89)
Armature.data.edit_bones['pelvis'].parent = Armature.data.edit_bones['root']
Armature.data.edit_bones['pelvis'].use_connect = False
#add spine_01
spine_01 = ArmContx.data.edit_bones.new('spine_01')
#....continues
## add physics bone groups
if True: ## Physics bones need special prefixes PHY_07_
#add PHY_07_bellyShake_MAIN_l
PHY_07_bellyShake_MAIN_l = ArmContx.data.edit_bones.new('PHY_07_bellyShake_MAIN_l')
PHY_07_bellyShake_MAIN_l.head = findEmpty('PHY_07_bellyShake_MAIN_l_head')
PHY_07_bellyShake_MAIN_l.tail = findEmpty('PHY_07_bellyShake_MAIN_l_tail')
PHY_07_bellyShake_MAIN_l.roll = m.radians(60)
Armature.data.edit_bones['PHY_07_bellyShake_MAIN_l'].parent = Armature.data.edit_bones['spine_02_PhyINTR_l']
Armature.data.edit_bones['PHY_07_bellyShake_MAIN_l'].use_connect = False
#add PHY_07_bellyShake_topOuter_l
PHY_07_bellyShake_topOuter_l = ArmContx.data.edit_bones.new('PHY_07_bellyShake_topOuter_l')
PHY_07_bellyShake_topOuter_l.head = findEmpty('PHY_07_bellyShake_topOuter_l_head')
PHY_07_bellyShake_topOuter_l.tail = findEmpty('PHY_07_bellyShake_topOuter_l_tail')
PHY_07_bellyShake_topOuter_l.roll = m.radians(60)
Armature.data.edit_bones['PHY_07_bellyShake_topOuter_l'].parent = Armature.data.edit_bones['PHY_07_bellyShake_MAIN_l']
Armature.data.edit_bones['PHY_07_bellyShake_topOuter_l'].use_connect = False
#add PHY_07_bellyShake_bottomOuter_l
PHY_07_bellyShake_bottomOuter_l = ArmContx.data.edit_bones.new('PHY_07_bellyShake_bottomOuter_l')
PHY_07_bellyShake_bottomOuter_l.head = findEmpty('PHY_07_bellyShake_bottomOuter_l_head')
PHY_07_bellyShake_bottomOuter_l.tail = findEmpty('PHY_07_bellyShake_bottomOuter_l_tail')
PHY_07_bellyShake_bottomOuter_l.roll = m.radians(60)
Armature.data.edit_bones['PHY_07_bellyShake_bottomOuter_l'].parent = Armature.data.edit_bones['PHY_07_bellyShake_MAIN_l']
Armature.data.edit_bones['PHY_07_bellyShake_bottomOuter_l'].use_connect = False
#add PHY_07_bellyShake_bottomInner_l
PHY_07_bellyShake_bottomInner_l = ArmContx.data.edit_bones.new('PHY_07_bellyShake_bottomInner_l')
PHY_07_bellyShake_bottomInner_l.head = findEmpty('PHY_07_bellyShake_bottomInner_l_head')
PHY_07_bellyShake_bottomInner_l.tail = findEmpty('PHY_07_bellyShake_bottomInner_l_tail')
PHY_07_bellyShake_bottomInner_l.roll = m.radians(60)
Armature.data.edit_bones['PHY_07_bellyShake_bottomInner_l'].parent = Armature.data.edit_bones['PHY_07_bellyShake_MAIN_l']
Armature.data.edit_bones['PHY_07_bellyShake_bottomInner_l'].use_connect = False
"""
more code in this section.
- All creating the bones of the rig
- setting the parent child relationship.
- Set non-deforming bones to false
- Set non-use inherit rotation to false
- Set non-use inherit scale to false
- changing rotation mode to either euler or quanternion
- adding controllers
Skipping a few sections to constraints.
example adding constraints
"""
# Symmetrize bones to right side
SelectSymmetrize()
#############################################
############## ADD CONSTRAINTS ##############
#############################################
#add constraints to------------ calf_IKCONST_l
calf_IKCONST_l = AddConstraint('IK', 'calf_l', 'ikHandleLeg_l', polsubtar='poleVectorLeg_l')
calf_IKCONST_l.name = 'calf_IKCONST_l'
calf_IKCONST_l.pole_angle = m.radians(0)
calf_IKCONST_l.chain_count = 2
calf_IKCONST_l.use_tail = True
calf_IKCONST_l.use_stretch = True
calf_IKCONST_l.influence = 1
#add constraints to------------ autoPoleNormLeg_0_DAMPTRK_l
autoPoleNormLeg_0_DAMPTRK_l = AddConstraint('DAMPED_TRACK', 'autoPoleNormLeg_0_l', 'autoPoleNormLeg_2_l')
autoPoleNormLeg_0_DAMPTRK_l.name = 'autoPoleNormLeg_0_DAMPTRK_l'
autoPoleNormLeg_0_DAMPTRK_l.head_tail = 0
autoPoleNormLeg_0_DAMPTRK_l.track_axis = 'TRACK_Y'
autoPoleNormLeg_0_DAMPTRK_l.influence = 1
if True:# always true. just for formating
#add constraints to------------ autoPoleNormLeg_1_COPLOC_01_l
autoPoleNormLeg_1_COPLOC_01_l = AddConstraint('COPY_LOCATION', 'autoPoleNormLeg_1_l', 'autoPoleNormLeg_0_l')
autoPoleNormLeg_1_COPLOC_01_l.name = 'autoPoleNormLeg_1_COPLOC_01_l'
autoPoleNormLeg_1_COPLOC_01_l.head_tail = 0
autoPoleNormLeg_1_COPLOC_01_l.use_x = True
autoPoleNormLeg_1_COPLOC_01_l.use_y = True
autoPoleNormLeg_1_COPLOC_01_l.use_z = True
autoPoleNormLeg_1_COPLOC_01_l.target_space = 'WORLD'
autoPoleNormLeg_1_COPLOC_01_l.owner_space = 'WORLD'
autoPoleNormLeg_1_COPLOC_01_l.influence = 1
#add constraints to------------ autoPoleNormLeg_1_COPLOC_02_l
autoPoleNormLeg_1_COPLOC_02_l = AddConstraint('COPY_LOCATION', 'autoPoleNormLeg_1_l', 'autoPoleNormLeg_2_l')
autoPoleNormLeg_1_COPLOC_02_l.name = 'autoPoleNormLeg_1_COPLOC_02_l'
autoPoleNormLeg_1_COPLOC_02_l.head_tail = 0
autoPoleNormLeg_1_COPLOC_02_l.use_x = True
autoPoleNormLeg_1_COPLOC_02_l.use_y = True
autoPoleNormLeg_1_COPLOC_02_l.use_z = True
autoPoleNormLeg_1_COPLOC_02_l.target_space = 'WORLD'
autoPoleNormLeg_1_COPLOC_02_l.owner_space = 'WORLD'
autoPoleNormLeg_1_COPLOC_02_l.influence = 0.5
#add constraints to------------ autoPoleNormLeg_1_COPROT_l
autoPoleNormLeg_1_COPROT_l = AddConstraint('COPY_ROTATION', 'autoPoleNormLeg_1_l', 'autoPoleNormLeg_2_l')
autoPoleNormLeg_1_COPROT_l.name = 'autoPoleNormLeg_1_COPROT_l'
autoPoleNormLeg_1_COPROT_l.use_x = True
autoPoleNormLeg_1_COPROT_l.use_y = True
autoPoleNormLeg_1_COPROT_l.use_z = True
autoPoleNormLeg_1_COPROT_l.target_space = 'WORLD'
autoPoleNormLeg_1_COPROT_l.owner_space = 'WORLD'
autoPoleNormLeg_1_COPROT_l.influence = 1
"""
more code in this section.
all more if this, adding contraints to bone
ie. IK, copy rotation, copy location, stretchto, damptrack, etc..
examples adding drivers
"""
#############################################
############## ADD DRIVERS ##################
#############################################
############## BONE DRIVERS ##################
#add driver to----------------- innerThighAdj_l
innerThighAdj_LocX_L = AddDriver("innerThighAdj_l", 'location', ['thigh_l', 'thigh_l'], ['ROT_X', 'ROT_Z'],\
['LOCAL_SPACE', 'LOCAL_SPACE'], 'abs(var0*.3) if var0>0 else (var1*.35)', varCount=2, channelIndex=0)
innerThighAdj_LocY_L = AddDriver("innerThighAdj_l", 'location', 'thigh_l', 'ROT_Z', 'LOCAL_SPACE', 'abs(var0*.45) if var0<0 else (var0*.45)', channelIndex=1)
innerThighAdj_LocZ_L = AddDriver("innerThighAdj_l", 'location', 'thigh_l', 'ROT_Z', 'LOCAL_SPACE', 'var0*.4 if var0<0 else -(var0*.3)', channelIndex=2)
innerThighAdj_LocX_R = AddDriver("innerThighAdj_r", 'location', ['thigh_r', 'thigh_r'], ['ROT_X', 'ROT_Z'],\
['LOCAL_SPACE', 'LOCAL_SPACE'], '-abs(var0*.3) if var0>0 else -(var1*.35)', varCount=2, channelIndex=0)
innerThighAdj_LocY_R = AddDriver("innerThighAdj_r", 'location', 'thigh_r', 'ROT_Z', 'LOCAL_SPACE', 'abs(var0*-.45) if var0>0 else -(var0*.45)', channelIndex=1)
innerThighAdj_LocZ_R = AddDriver("innerThighAdj_r", 'location', 'thigh_r', 'ROT_Z', 'LOCAL_SPACE', 'var0*-.4 if var0>0 else (var0*.3)', channelIndex=2)
#add driver to----------------- thigh_l
thigh_ScaleY_L = AddDriver('thigh_l', 'scale', 'thigh_l', 'ROT_Z', 'LOCAL_SPACE', 'max(1-abs(var0 *.03), .98)', channelIndex=1)
thigh_ScaleY_R = AddDriver('thigh_r', 'scale', 'thigh_r', 'ROT_Z', 'LOCAL_SPACE', 'max(1-abs(var0 *.03), .98)', channelIndex=1)
thigh_ScaleY_L = AddDriver('thigh_l', 'scale', 'thigh_l', 'ROT_Z', 'LOCAL_SPACE', 'max(1-abs(var0 *.03), .98)', channelIndex=1)
thigh_ScaleY_R = AddDriver('thigh_r', 'scale', 'thigh_r', 'ROT_Z', 'LOCAL_SPACE', 'max(1-abs(var0 *-.03), .98)', channelIndex=1)
### examples adding property drivers
############## PROPERTY DRIVERS ##################
#add driver to----------------- sideMoveHip_l
sideMoveHip_ScaleX_l = AddPropertyDriver('sideMoveHip_l', 'scale', 'PROPERTIES_SPHERE', '["Hip_Width"]', '(var*3) + 1.0', channelIndex=0)
sideMoveHip_ScaleX_r = AddPropertyDriver('sideMoveHip_r', 'scale', 'PROPERTIES_SPHERE', '["Hip_Width"]', '(var*3) + 1.0', channelIndex=0)
sideMoveHip_ScaleZ_l = AddPropertyDriver('sideMoveHip_l', 'scale', 'PROPERTIES_SPHERE', '["Hip_Width"]', '(var*3) + 1.0', channelIndex=2)
sideMoveHip_ScaleZ_r = AddPropertyDriver('sideMoveHip_r', 'scale', 'PROPERTIES_SPHERE', '["Hip_Width"]', '(var*3) + 1.0', channelIndex=2)
### examples adding constraint drivers
############## CONSTRAINT DRIVERS ##################
#add driver to----------------- pelvis_LIMLOC_DRIV
pelvis_LIMLOC_DRIV_package = 'pose.bones["pelvis"].constraints["pelvis_LIMLOC"].influence'
pelvis_LIMLOC_DRIV = AddPropertyDriver('pelvis', '', ['PROPERTIES_SPHERE', 'PROPERTIES_SPHERE'], ['["Hip_Width"]', '["Thigh_Size"]'],\
'-4.0 if var0>.05 or var1>.1 else -5', varCount=2, package=pelvis_LIMLOC_DRIV_package)
### Utility code for mirroring skin weights from left to right
#########################################
############## UTILITY ##################
#########################################
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects['body1'].select_set(True)
bpy.context.view_layer.objects.active = bpy.data.objects['body1']
bpy.ops.object.mode_set(mode='WEIGHT_PAINT')
for grp in bpy.context.object.vertex_groups:
if grp.name[-2:] == '_r':
other_side = bpy.context.object.vertex_groups[grp.name].index
bpy.context.object.vertex_groups.active_index = other_side
bpy.ops.object.vertex_group_remove(all=False, all_unlocked=False)
for grp in bpy.context.object.vertex_groups:
if grp.name[-2:] == '_l':
act = bpy.context.object.vertex_groups[grp.name].index
bpy.context.object.vertex_groups.active_index = act
bpy.ops.object.vertex_group_copy()
bpy.ops.object.vertex_group_mirror(use_topology=False)
if 'PHY_' in grp.name:
for i in range(1,12,2):
if grp.name[4:6] == f'0{i}':
new_name = f'PHY_0{i+1}' + grp.name[6:-2] + '_r'
elif grp.name[4:6] == f'{i}':
new_name = f'PHY_{i+1}' + grp.name[6:-2] + '_r'
else:
new_name = grp.name[:-2]+'_r'
bpy.context.object.vertex_groups[grp.name+'_copy'].name = new_name
else:
pass
## Hide all bones that are not controller bones used to animate
#########################################################################
###### add property driver to show/hide the non-controller bones ########
#########################################################################
con_list = ['spine_02', 'pelvis', 'ikHandleArm_r', 'ikHandleArm_l', 'poleVectorLeg_r', 'poleVectorLeg_l',\
'neck_02', 'spine_04', 'foot_CON_l', 'footRoll_CON_l', 'foot_CON_r', 'footRoll_CON_r',\
'poleVectorArm_l', 'poleVectorArm_r', 'hand_l', 'hand_r']
hidden_bones = {}
for bone in bpy.context.object.pose.bones:
if bone.name not in con_list:
drive = bpy.data.objects[rig].pose.bones[bone.name].bone.driver_add('hide')
drive.driver.type = 'SCRIPTED'
drive.driver.expression = 'var'
var = drive.driver.variables.new()
var.name = 'var'
var.type = 'SINGLE_PROP'
var.targets[0].id = bpy.data.objects['PROPERTIES_SPHERE']
var.targets[0].data_path = '["_INTERNAL_VISIBILITY"]'
hidden_bones[f"hide_{bone.name}"] = drive
## example adding Physics
#############################################
############## ADD PHYSICS ##################
#############################################
add_Physics('spine_02_PhyINTR_l', 'PHY_07')
add_Physics('spine_02_PhyINTR_r', 'PHY_08')
## adding physics drivers
#add driver to----------------- PHY_mesh_spine_02_PhyINTR_FRICTION_DRIV_l
PHY_mesh_spine_02_PhyINTR_FRICTION_DRIV_l = Add_PHY_PropertyDriver("PHY_mesh_spine_02_PhyINTR_l", 'Softbody',\
'friction', 'PROPERTIES_SPHERE', '["phyFRICTION_stomach"]')
#add driver to----------------- PHY_mesh_spine_02_PhyINTR_FRICTION_DRIV_r
PHY_mesh_spine_02_PhyINTR_FRICTION_DRIV_r = Add_PHY_PropertyDriver("PHY_mesh_spine_02_PhyINTR_r", 'Softbody',\
'friction', 'PROPERTIES_SPHERE', '["phyFRICTION_stomach"]')
#add driver to----------------- PHY_mesh_spine_02_PhyINTR_MASS_DRIV_l
PHY_mesh_spine_02_PhyINTR_MASS_DRIV_l = Add_PHY_PropertyDriver("PHY_mesh_spine_02_PhyINTR_l", 'Softbody',\
'mass', 'PROPERTIES_SPHERE', '["phyMASS_stomach"]')
#add driver to----------------- PHY_mesh_spine_02_PhyINTR_MASS_DRIV_r
PHY_mesh_spine_02_PhyINTR_MASS_DRIV_r = Add_PHY_PropertyDriver("PHY_mesh_spine_02_PhyINTR_r", 'Softbody',\
'mass', 'PROPERTIES_SPHERE', '["phyMASS_stomach"]')
## Final clean up stuff
#####################################################################################
###### change Rest Pose, add Armature Modifiers, Bone Parent other meshes ###########
#####################################################################################
## set rest pose for major driving bones
bpy.ops.object.posemode_toggle()
restlist = ['thigh_l', 'thigh_r', 'calf_l', 'calf_r']
for bone in bpy.context.object.pose.bones:
bone.bone.select = False
for res in restlist:
bpy.context.object.pose.bones[res].bone.select = True
bpy.ops.pose.armature_apply(selected=True)
## reset rest length of all stretch to constraints
for bone in bpy.data.objects[rig].pose.bones:
for const in bone.constraints:
if const.type == 'STRETCH_TO':
bpy.context.object.data.bones.active = bone.bone
bpy.ops.constraint.stretchto_reset(constraint=const.name, owner='BONE')
## apply armature modifier to character mesh objects
bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
meshlist = bpy.data.collections[character].all_objects
for mes in meshlist:
mes.modifiers['Armature'].object = bpy.data.objects[rig]
## bone parent the characters eyes and the property sphere to the head bone
for o in bpy.data.objects:
if 'Auto_Eye' in o.name or 'PROPERTIES_SPHERE' in o.name:
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects[rig].select_set(True)
bpy.context.view_layer.objects.active = bpy.data.objects[rig]
bpy.ops.object.mode_set(mode='POSE')
bpy.context.object.pose.bones['head'].bone.select = True
bpy.context.object.data.bones.active = bpy.context.object.pose.bones['head'].bone
bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects[o.name].select_set(True)
bpy.data.objects[rig].select_set(True)
bpy.ops.object.parent_set(type='BONE', keep_transform=True)
bpy.data.objects['PROPERTIES_SPHERE'].select_set(False)
#######################################################################
#######################################################################
#######################################################################
