Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
import pymel.core as pm
import maya.mel as mel
import re
'''
Radio button for point lock activation
'''
def button_base( *args ) :
intFieldData_seq = pm.intField( intFieldEntry_seq, editable = True, query = True, value = True)
global radioButton_follicle
radioButton_follicle=0
def button_tip( *args ) :
intFieldData_seq = pm.intField( intFieldEntry_seq, editable = True, query = True, value = True)
global radioButton_follicle
radioButton_follicle=1
def button_both_end( *args ) :
intFieldData_seq = pm.intField( intFieldEntry_seq, editable = True, query = True, value = True)
global radioButton_follicle
radioButton_follicle=2
'''
Radio button for Self Collision activation
'''
def self_col_on( *args ) :
global checkBox_self_col
checkBox_self_col = 1
def self_col_off( *args ) :
global checkBox_self_col
checkBox_self_col = 0
'''
Radio button for Self Collision activation
'''
def col_on( *args ) :
global checkBox_col
checkBox_col = 1
def col_off( *args ) :
global checkBox_col
checkBox_col = 0
'''
Create dynamic hair with multi curve
'''
def hair_joint_multi( *args ) :
'''
Collect Data
'''
intFieldData_num_joint = pm.intField( intFieldEntry_num_joint, editable = True, query = True, value = True)
intFieldData_seq = pm.intField( intFieldEntry_seq, editable = True, query = True, value = True)
if intFieldData_seq == 0 :
seq_curve = intFieldData_seq
elif intFieldData_seq > 0 :
seq_curve = intFieldData_seq - 1
if pm.objExists( 'hair_{0}_01_bind'.format( seq_curve + 1 ) ) :
print 'Error on naming sequence'
else :
list_curve = pm.ls( sl= True )
for item in list_curve :
seq_curve = seq_curve + 1
'''
Collect Data
'''
intFieldData_num_joint = pm.intField( intFieldEntry_num_joint, editable = True, query = True, value = True)
'''
Method on reconstruct curve and rename
'''
pm.rebuildCurve( item , ch=1, rpo=1 , rt=0 , end=1 , kr=0 , kcp=0 , kep=1 , kt=0 , s=intFieldData_num_joint, d=3 , tol=0.0001 )
name_curve = pm.rename( item , 'hair_{0}_curve'.format( seq_curve ) )
'''
Method on create joint along curve
'''
pre_joint = ''
root_joint = ''
for i in range( 0 , intFieldData_num_joint ) :
user_default_unit = pm.currentUnit( query=True, linear=True )
pm.currentUnit( linear = 'cm' )
pm.select( cl = True )
new_joint = pm.joint()
mot_path = pm.pathAnimation( new_joint , c = item , fm = True )
pm.cutKey( mot_path + '.u' )
pm.setAttr( mot_path + '.u', i * ( 1.0 / ( intFieldData_num_joint - 1 )) )
pm.delete( '{0}.{1}'.format( new_joint , 'tx' ) , icn = True )
pm.delete( '{0}.{1}'.format( new_joint , 'ty' ) , icn = True )
pm.delete( '{0}.{1}'.format( new_joint , 'tz' ) , icn = True )
pm.currentUnit( linear = '{0}'.format(user_default_unit) )
renaming_item = pm.ls( sl = True )
if i == 0 :
pre_joint = new_joint
root_joint = new_joint
pm.rename( renaming_item , 'hair_{0}_{1:02d}_bind'.format( seq_curve ,i+1 ) )
continue
elif i < intFieldData_num_joint - 1 :
pm.rename( renaming_item , 'hair_{0}_{1:02d}_bind'.format( seq_curve ,i+1 ) )
else :
pm.rename( renaming_item , 'hair_{0}_{1:02d}_waste'.format( seq_curve ,i+1 ) )
pm.parent( new_joint , pre_joint )
pre_joint = new_joint
pm.joint( root_joint, e = True , zso = True, oj = 'xyz' , ch = True , sao = 'yup' )
'''
Method on create dynamic curve
'''
pm.select( name_curve )
mel.eval('makeCurvesDynamic 2 { "0", "0", "1", "1", "0"}')
pm.hide(item)
pm.parent( 'hairSystem{0}Follicles'.format(seq_curve) , 'hair_{0}_01_bind'.format(seq_curve) )
output_curve_selected = pm.listRelatives( 'hairSystem{0}OutputCurves'.format(seq_curve) , c=1 )
output_curve = pm.rename( output_curve_selected , 'hair_{0}_output_curve'.format( seq_curve ) )
'''
Method on IK Spline
'''
pm.ikHandle(sj='hair_{0}_02_bind'.format(seq_curve), ee='hair_{0}_{1:02d}_waste'.format(seq_curve , intFieldData_num_joint ),c=output_curve, n = 'hair_{0}_ik'.format( seq_curve ), sol= 'ikSplineSolver' , createCurve = False, simplifyCurve = False, rootOnCurve = False , twistType = 'linear' , createRootAxis = False , parentCurve= False, snapCurve = False , rootTwistMode = False)
'''
Method on changing pointLock of dynamic curve
'''
if radioButton_follicle == 0 :
curve_follicle = 'follicleShape{0}'.format(seq_curve)
pm.setAttr(curve_follicle + ".pointLock", 1)
elif radioButton_follicle == 1 :
curve_follicle = 'follicleShape{0}'.format(seq_curve)
pm.setAttr(curve_follicle + ".pointLock", 2)
else :
curve_follicle = 'follicleShape{0}'.format(seq_curve)
pm.setAttr(curve_follicle + ".pointLock", 3)
print '-'*100
print 'dynamic hair created, proceed to attritube'
print '-'*100
'''
Create group if not exist
'''
if pm.objExists('hair_system_group'):
print 'group already exist'
else :
pm.group(em = True, n='hair_system_group' , w = True)
if pm.objExists('hair_ik_group'):
print 'group already exist'
else :
pm.group(em = True, n='hair_ik_group' , w = True)
if pm.objExists('hair_output_group'):
print 'group already exist'
else :
pm.group(em = True, n='hair_output_group' , w = True)
if pm.objExists('hair_joint_group'):
print 'group already exist'
else :
pm.group(em = True, n='hair_joint_group' , w = True)
'''
Parent object to existing group
'''
if pm.objExists('hair_system_group') :
pm.parent( 'hairSystem{0}'.format(seq_curve) , 'hair_system_group')
else :
print 'group not exist'
if pm.objExists('hair_ik_group'):
pm.parent( 'hair_{0}_ik'.format(seq_curve) , 'hair_ik_group' )
else :
print 'group not exist'
if pm.objExists('hair_output_group'):
pm.parent( 'hairSystem{0}OutputCurves'.format(seq_curve) , 'hair_output_group' )
else :
print 'group not exist'
if pm.objExists('hair_joint_group'):
pm.parent( 'hair_{0}_01_bind'.format( seq_curve ) , 'hair_joint_group' )
else :
print 'group not exist'
def dyn_curve_attr ( *args ) :
list_hair_curve = pm.ls(sl=True)
for item_hair_curve in list_hair_curve :
'''
Collect Data
'''
str_item_hair_curve = str(item_hair_curve)
allNum_curve = re.findall(r'\d+',str_item_hair_curve)
num_seq_curve = allNum_curve[0]
hair_joint_rel = pm.select( 'hair_{0}_01_bind'.format(num_seq_curve) )
last_jnt = pm.listRelatives( allDescendents=True , type = 'joint' )[0]
str_last_jnt = str(last_jnt)
allNum_joint = re.findall(r'\d+',str_last_jnt)
int_allNum_joint = int(allNum_joint[1])
floatFieldData_joint_size = pm.floatSliderGrp ( floatFieldEntry_joint_size , query = True, value = True)
floatFieldData_stretch_res = pm.floatSliderGrp ( floatFieldEntry_stretch_res , query = True, value = True)
floatFieldData_compress_res = pm.floatSliderGrp ( floatFieldEntry_compress_res , query = True, value = True)
floatFieldData_bend_res = pm.floatSliderGrp ( floatFieldEntry_bend_res , query = True, value = True)
floatFieldData_twist_res = pm.floatSliderGrp ( floatFieldEntry_twist_res , query = True, value = True)
floatFieldData_curve_att = pm.floatSliderGrp ( floatFieldEntry_curve_att , query = True, value = True)
floatFieldData_curve_att_damp = pm.floatSliderGrp ( floatFieldEntry_curve_att_damp , query = True, value = True)
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
'''
Method on changing SelfCollision of dynamic curve
'''
if checkBox_self_col == 0 :
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
pm.setAttr( curve_hair_sys + ".selfCollide", 0 )
elif checkBox_self_col == 1 :
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
pm.setAttr( curve_hair_sys + ".selfCollide", 1 )
'''
Method on changing Collision of dynamic curve
'''
if checkBox_col == 0 :
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
pm.setAttr( curve_hair_sys + ".collide", 0 )
elif checkBox_col == 1 :
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
pm.setAttr( curve_hair_sys + ".collide", 1 )
'''
Method on changing size of joint
'''
for i in range( 1 , int_allNum_joint + 1 ) :
if i < int_allNum_joint :
hair_joint_edit = 'hair_{0}_{1:02d}_bind'.format( num_seq_curve ,i )
elif i == int_allNum_joint :
hair_joint_edit = 'hair_{0}_{1:02d}_waste'.format( num_seq_curve ,i )
pm.setAttr( hair_joint_edit + '.radius' , floatFieldData_joint_size )
'''
Method on changing attribute of dynamic curve
'''
pm.setAttr( curve_hair_sys + '.stretchResistance' , floatFieldData_stretch_res )
pm.setAttr( curve_hair_sys + '.compressionResistance' , floatFieldData_compress_res )
pm.setAttr( curve_hair_sys + '.bendResistance' , floatFieldData_bend_res )
pm.setAttr( curve_hair_sys + '.twistResistance' , floatFieldData_twist_res )
pm.setAttr( curve_hair_sys + '.startCurveAttract' , floatFieldData_curve_att )
pm.setAttr( curve_hair_sys + '.attractionDamp' , floatFieldData_curve_att_damp )
def nucleus_name_changed ( *args ) :
print 'Nucleus name had changed to ' + nucleus_located
'''
locate nucleus
'''
global nucleus_located
nucleus_located = 'nucleus1'
if pm.objExists(nucleus_located) :
nucleus_located = pm.rename ( nucleus_located , 'nucleus1' )
else :
print 'nucleus1 not in the scene'
print 'Create nucleus1 or rename nucleus name back to nucleus1 and run again'
pm.scriptJob( killAll = True )
pm.scriptJob( e = [ 'NameChanged' , nucleus_name_changed ] , cu = True )
def dyn_nucleus_attr ( *args ) :
'''
Collect Data
'''
floatFieldData_gravity = pm.floatSliderGrp ( floatFieldEntry_gravity , query = True, value = True )
floatFieldData_gravityDirectionX = pm.floatSliderGrp ( floatFieldEntry_gravityDirectionX , query = True, value = True )
floatFieldData_gravityDirectionY = pm.floatSliderGrp ( floatFieldEntry_gravityDirectionY , query = True, value = True )
floatFieldData_gravityDirectionZ = pm.floatSliderGrp ( floatFieldEntry_gravityDirectionZ , query = True, value = True )
floatFieldData_airDensity = pm.floatSliderGrp ( floatFieldEntry_airDensity , query = True, value = True )
floatFieldData_windSpeed = pm.floatSliderGrp ( floatFieldEntry_windSpeed , query = True, value = True )
floatFieldData_windDirectionX = pm.floatSliderGrp ( floatFieldEntry_windDirectionX , query = True, value = True )
floatFieldData_windDirectionY = pm.floatSliderGrp ( floatFieldEntry_windDirectionY , query = True, value = True )
floatFieldData_windDirectionZ = pm.floatSliderGrp ( floatFieldEntry_windDirectionZ , query = True, value = True )
floatFieldData_windNoise = pm.floatSliderGrp ( floatFieldEntry_windNoise , query = True, value = True )
floatFieldData_maxCollisionIterations = pm.floatSliderGrp ( floatFieldEntry_maxCollisionIterations , query = True, value = True )
'''
Method on changing attribute of nucleus
'''
pm.setAttr( '{0}.gravity'.format(nucleus_located) , floatFieldData_gravity )
pm.setAttr( '{0}.gravityDirectionX'.format(nucleus_located) , floatFieldData_gravityDirectionX )
pm.setAttr( '{0}.gravityDirectionY'.format(nucleus_located) , floatFieldData_gravityDirectionY )
pm.setAttr( '{0}.gravityDirectionZ'.format(nucleus_located) , floatFieldData_gravityDirectionZ )
pm.setAttr( '{0}.airDensity'.format(nucleus_located) , floatFieldData_airDensity )
pm.setAttr( '{0}.windSpeed'.format(nucleus_located) , floatFieldData_windSpeed )
pm.setAttr( '{0}.windDirectionX'.format(nucleus_located) , floatFieldData_windDirectionX )
pm.setAttr( '{0}.windDirectionY'.format(nucleus_located) , floatFieldData_windDirectionY )
pm.setAttr( '{0}.windDirectionZ'.format(nucleus_located) , floatFieldData_windDirectionZ )
pm.setAttr( '{0}.windNoise'.format(nucleus_located) , floatFieldData_windNoise )
pm.setAttr( '{0}.maxCollisionIterations'.format(nucleus_located) , floatFieldData_maxCollisionIterations )
def dyn_nucleus_attr_default ( *args ) :
'''
Method on changing attribute of nucleus back to default
'''
pm.setAttr( '{0}.gravity'.format(nucleus_located) , 9.8 )
pm.setAttr( '{0}.gravityDirectionX'.format(nucleus_located) , 0 )
pm.setAttr( '{0}.gravityDirectionY'.format(nucleus_located) , -1 )
pm.setAttr( '{0}.gravityDirectionZ'.format(nucleus_located) , 0 )
pm.setAttr( '{0}.airDensity'.format(nucleus_located) , 1 )
pm.setAttr( '{0}.windSpeed'.format(nucleus_located) , 0 )
pm.setAttr( '{0}.windDirectionX'.format(nucleus_located) , 1 )
pm.setAttr( '{0}.windDirectionY'.format(nucleus_located) , 0 )
pm.setAttr( '{0}.windDirectionZ'.format(nucleus_located) , 0 )
pm.setAttr( '{0}.windNoise'.format(nucleus_located) , 0 )
pm.setAttr( '{0}.maxCollisionIterations'.format(nucleus_located) , 4 )
floatFieldEntry_gravity.setValue( 9.8 )
floatFieldEntry_gravityDirectionX.setValue( 0 )
floatFieldEntry_gravityDirectionY.setValue( -1 )
floatFieldEntry_gravityDirectionZ.setValue( 0 )
floatFieldEntry_airDensity.setValue( 1 )
floatFieldEntry_windSpeed.setValue( 0 )
floatFieldEntry_windDirectionX.setValue( 1 )
floatFieldEntry_windDirectionY.setValue( 0 )
floatFieldEntry_windDirectionZ.setValue( 0 )
floatFieldEntry_windNoise.setValue( 0 )
floatFieldEntry_maxCollisionIterations.setValue( 4 )
def dyn_curve_attr_rough_low (*args) :
list_hair_curve = pm.ls(sl=True)
for item_hair_curve in list_hair_curve :
'''
Collect Data
'''
str_item_hair_curve = str(item_hair_curve)
allNum_curve = re.findall(r'\d+',str_item_hair_curve)
num_seq_curve = allNum_curve[0]
hair_joint_rel = pm.select( 'hair_{0}_01_bind'.format(num_seq_curve) )
last_jnt = pm.listRelatives( allDescendents=True , type = 'joint' )[0]
str_last_jnt = str(last_jnt)
allNum_joint = re.findall(r'\d+',str_last_jnt)
int_allNum_joint = int(allNum_joint[1])
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
pm.setAttr( curve_hair_sys + ".selfCollide", 1 )
pm.setAttr( curve_hair_sys + ".collide", 1 )
pm.setAttr( curve_hair_sys + '.stretchResistance' , 100 )
pm.setAttr( curve_hair_sys + '.compressionResistance' , 70 )
pm.setAttr( curve_hair_sys + '.bendResistance' , 50 )
pm.setAttr( curve_hair_sys + '.twistResistance' , 80 )
pm.setAttr( curve_hair_sys + '.startCurveAttract' , 0.1 )
pm.setAttr( curve_hair_sys + '.attractionDamp' , 0.05 )
floatFieldEntry_stretch_res.setValue( 100 )
floatFieldEntry_compress_res.setValue( 70 )
floatFieldEntry_bend_res.setValue( 50 )
floatFieldEntry_twist_res.setValue( 80 )
floatFieldEntry_curve_att.setValue( 0.1 )
floatFieldEntry_curve_att_damp.setValue( 0.05 )
collision_dyn.setValue( 1 )
selfCollision_dyn.setValue( 1 )
def dyn_curve_attr_rough_medium (*args) :
list_hair_curve = pm.ls(sl=True)
for item_hair_curve in list_hair_curve :
'''
Collect Data
'''
str_item_hair_curve = str(item_hair_curve)
allNum_curve = re.findall(r'\d+',str_item_hair_curve)
num_seq_curve = allNum_curve[0]
hair_joint_rel = pm.select( 'hair_{0}_01_bind'.format(num_seq_curve) )
last_jnt = pm.listRelatives( allDescendents=True , type = 'joint' )[0]
str_last_jnt = str(last_jnt)
allNum_joint = re.findall(r'\d+',str_last_jnt)
int_allNum_joint = int(allNum_joint[1])
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
pm.setAttr( curve_hair_sys + ".selfCollide", 1 )
pm.setAttr( curve_hair_sys + ".collide", 1 )
pm.setAttr( curve_hair_sys + '.stretchResistance' , 120 )
pm.setAttr( curve_hair_sys + '.compressionResistance' , 100 )
pm.setAttr( curve_hair_sys + '.bendResistance' , 70 )
pm.setAttr( curve_hair_sys + '.twistResistance' , 120 )
pm.setAttr( curve_hair_sys + '.startCurveAttract' , 0.3 )
pm.setAttr( curve_hair_sys + '.attractionDamp' , 0.1 )
floatFieldEntry_stretch_res.setValue( 120 )
floatFieldEntry_compress_res.setValue( 100 )
floatFieldEntry_bend_res.setValue( 70 )
floatFieldEntry_twist_res.setValue( 120 )
floatFieldEntry_curve_att.setValue( 0.3 )
floatFieldEntry_curve_att_damp.setValue( 0.1 )
collision_dyn.setValue( 1 )
selfCollision_dyn.setValue( 1 )
def dyn_curve_attr_rough_high (*args) :
list_hair_curve = pm.ls(sl=True)
print list_hair_curve
for item_hair_curve in list_hair_curve :
'''
Collect Data
'''
str_item_hair_curve = str(item_hair_curve)
allNum_curve = re.findall(r'\d+',str_item_hair_curve)
num_seq_curve = allNum_curve[0]
hair_joint_rel = pm.select( 'hair_{0}_01_bind'.format(num_seq_curve) )
last_jnt = pm.listRelatives( allDescendents=True , type = 'joint' )[0]
str_last_jnt = str(last_jnt)
allNum_joint = re.findall(r'\d+',str_last_jnt)
int_allNum_joint = int(allNum_joint[1])
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
pm.setAttr( curve_hair_sys + ".selfCollide", 1 )
pm.setAttr( curve_hair_sys + ".collide", 1 )
dyn_curve_prop_stretch_res = pm.setAttr( curve_hair_sys + '.stretchResistance' , 145 )
dyn_curve_prop_compress_res = pm.setAttr( curve_hair_sys + '.compressionResistance' , 125 )
dyn_curve_prop_bend_res = pm.setAttr( curve_hair_sys + '.bendResistance' , 100 )
dyn_curve_prop_twist_res = pm.setAttr( curve_hair_sys + '.twistResistance' , 150 )
dyn_curve_prop_curve_att = pm.setAttr( curve_hair_sys + '.startCurveAttract' , 0.5 )
dyn_curve_prop_curve_att_damp = pm.setAttr( curve_hair_sys + '.attractionDamp' , 0.15 )
floatFieldEntry_stretch_res.setValue( 145 )
floatFieldEntry_compress_res.setValue( 125 )
floatFieldEntry_bend_res.setValue( 100 )
floatFieldEntry_twist_res.setValue( 150 )
floatFieldEntry_curve_att.setValue( 0.5 )
floatFieldEntry_curve_att_damp.setValue( 0.15 )
collision_dyn.setValue( 1 )
selfCollision_dyn.setValue( 1 )
'''
Window creation
'''
class window_creation :
def changing_properties( self , *args ) :
dyn_nucleus_prop_gravity = pm.getAttr('{0}.gravity'.format(nucleus_located))
dyn_nucleus_prop_gravityDirectionX = pm.getAttr('{0}.gravityDirectionX'.format(nucleus_located))
dyn_nucleus_prop_gravityDirectionY = pm.getAttr('{0}.gravityDirectionY'.format(nucleus_located))
dyn_nucleus_prop_gravityDirectionZ = pm.getAttr('{0}.gravityDirectionZ'.format(nucleus_located))
dyn_nucleus_prop_airDensity = pm.getAttr('{0}.airDensity'.format(nucleus_located))
dyn_nucleus_prop_windSpeed = pm.getAttr('{0}.windSpeed'.format(nucleus_located))
dyn_nucleus_prop_windDirectionX = pm.getAttr('{0}.windDirectionX'.format(nucleus_located))
dyn_nucleus_prop_windDirectionY = pm.getAttr('{0}.windDirectionY'.format(nucleus_located))
dyn_nucleus_prop_windDirectionZ = pm.getAttr('{0}.windDirectionZ'.format(nucleus_located))
dyn_nucleus_prop_windNoise = pm.getAttr('{0}.windNoise'.format(nucleus_located))
dyn_nucleus_prop_maxCollisionIterations = pm.getAttr('{0}.maxCollisionIterations'.format(nucleus_located))
self.floatFieldEntry_gravity.setValue( dyn_nucleus_prop_gravity )
self.floatFieldEntry_gravityDirectionX.setValue( dyn_nucleus_prop_gravityDirectionX )
self.floatFieldEntry_gravityDirectionY.setValue( dyn_nucleus_prop_gravityDirectionY )
self.floatFieldEntry_gravityDirectionZ.setValue( dyn_nucleus_prop_gravityDirectionZ )
self.floatFieldEntry_airDensity.setValue( dyn_nucleus_prop_airDensity )
self.floatFieldEntry_windSpeed.setValue( dyn_nucleus_prop_windSpeed )
self.floatFieldEntry_windDirectionX.setValue( dyn_nucleus_prop_windDirectionX )
self.floatFieldEntry_windDirectionY.setValue( dyn_nucleus_prop_windDirectionY )
self.floatFieldEntry_windDirectionZ.setValue( dyn_nucleus_prop_windDirectionZ )
self.floatFieldEntry_windNoise.setValue( dyn_nucleus_prop_windNoise )
self.floatFieldEntry_maxCollisionIterations.setValue( dyn_nucleus_prop_maxCollisionIterations )
'''
Collect data
'''
list_hair_curve = pm.ls(sl=True)
for item_hair_curve in list_hair_curve :
if len(list_hair_curve) > 0 :
first_item_hair_curve = list_hair_curve[0]
str_item_hair_curve = str(first_item_hair_curve)
allNum_curve = re.findall(r'\d+',str_item_hair_curve)
num_seq_curve = allNum_curve[0]
curve_hair_sys = 'hairSystemShape{0}'.format(num_seq_curve)
'''
set value for ui based on selection
'''
if item_hair_curve == 'hair_{0}_output_curve'.format(num_seq_curve) :
print ' '
print '-'*100
print first_item_hair_curve + ' is the first hair curve to show properties'
dyn_curve_prop_collision = pm.getAttr (curve_hair_sys + '.collide')
dyn_curve_prop_self_collision = pm.getAttr (curve_hair_sys + '.selfCollide')
dyn_curve_prop_stretch_res = pm.getAttr( curve_hair_sys + '.stretchResistance' )
dyn_curve_prop_compress_res = pm.getAttr( curve_hair_sys + '.compressionResistance' )
dyn_curve_prop_bend_res = pm.getAttr( curve_hair_sys + '.bendResistance' )
dyn_curve_prop_twist_res = pm.getAttr( curve_hair_sys + '.twistResistance' )
dyn_curve_prop_curve_att = pm.getAttr( curve_hair_sys + '.startCurveAttract' )
dyn_curve_prop_curve_att_damp = pm.getAttr( curve_hair_sys + '.attractionDamp' )
if dyn_curve_prop_collision == True :
collision_on_off = 1
else :
collision_on_off = 0
if dyn_curve_prop_self_collision == True :
selfCollision_on_off = 1
else :
selfCollision_on_off = 0
'''
show the value of properties
'''
print' '
print'-'*100
if collision_on_off == 1 :
print 'Collision is On'
else :
print 'Collision is Off'
if selfCollision_on_off == 1 :
print 'Self Collision is On'
else :
print 'Self Collision is Off'
print 'stretch resistance = {0} '.format(dyn_curve_prop_stretch_res)
print 'compress resistance = {0} '.format(dyn_curve_prop_compress_res)
print 'bend resistance = {0} '.format(dyn_curve_prop_bend_res)
print 'twist resistance = {0} '.format(dyn_curve_prop_twist_res)
print 'curve attraction = {0} '.format(dyn_curve_prop_curve_att)
print 'curve attraction damp = {0} '.format(dyn_curve_prop_curve_att_damp)
print'-'*100
print' '
self.floatFieldEntry_stretch_res.setValue( dyn_curve_prop_stretch_res )
self.floatFieldEntry_compress_res.setValue( dyn_curve_prop_compress_res )
self.floatFieldEntry_bend_res.setValue( dyn_curve_prop_bend_res )
self.floatFieldEntry_twist_res.setValue( dyn_curve_prop_twist_res )
self.floatFieldEntry_curve_att.setValue( dyn_curve_prop_curve_att )
self.floatFieldEntry_curve_att_damp.setValue( dyn_curve_prop_curve_att_damp )
self.collision_dyn.setValue( collision_on_off )
self.selfCollision_dyn.setValue( selfCollision_on_off )
else :
dyn_curve_prop_stretch_res = 0
dyn_curve_prop_compress_res = 0
dyn_curve_prop_bend_res = 0
dyn_curve_prop_twist_res = 0
dyn_curve_prop_curve_att = 0
dyn_curve_prop_curve_att_damp = 0
else :
print 'nothing selected or not output curve'
def __init__(self) :
self.ui_creation()
def ui_creation(self) :
if pm.window('hair_window' , exists = True ) :
pm.deleteUI('hair_window')
window = pm.window( 'hair_window' , title="HairRigging", iconName="SpeedHairRig", widthHeight=( 450,900 ) )
pm.columnLayout( )
pm.text(' ')
pm.text( 'Create Dynamic Hair Based on Curve' )
pm.text(' ')
pm.rowColumnLayout( nc=7, cw = [ (1,50),(2,40),(3,80),(4,70),(5,50),(6,60),(7,50) ] )
pm.radioCollection()
pm.radioButton(label = 'Base', editable = True, onCommand = button_base)
pm.radioButton(label = 'Tip', editable = True, onCommand = button_tip)
pm.radioButton(label = 'Both_End', editable = True, onCommand = button_both_end)
global intFieldName_num_joint
global intFieldEntry_num_joint
global intFieldName_seq
global intFieldEntry_seq
intFieldName_num_joint = pm.text( label= 'No_Joint :')
intFieldEntry_num_joint = pm.intField(intFieldName_num_joint, editable = True, value=0)
intFieldName_seq = pm.text( label= 'Sequence :')
intFieldEntry_seq = pm.intField(intFieldName_seq, editable = True, value=0)
pm.setParent('..')
pm.button( label="Create Hair Joint", width=400, command= hair_joint_multi )
pm.text(' ')
pm.setParent('..')
pm.columnLayout( )
pm.text('-'*100)
pm.text( 'Dynamic Curve Properties' )
pm.text(' ')
pm.rowColumnLayout( nc=3, cw = [ (1,50),(2,150),(3,150) ] )
pm.text(' ')
self.collision_dyn = pm.checkBox( label = 'Collision' , ofc = col_off , onc = col_on )
self.selfCollision_dyn = pm.checkBox( label = 'selfCollision' , ofc = self_col_off , onc = self_col_on )
global collision_dyn
global selfCollision_dyn
collision_dyn = self.collision_dyn
selfCollision_dyn = self.selfCollision_dyn
pm.setParent('..')
self.floatFieldEntry_joint_size = pm.floatSliderGrp ( label= 'Joint Size' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =0 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_stretch_res = pm.floatSliderGrp ( label= 'Stretch Resistance' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =0 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_compress_res = pm.floatSliderGrp ( label= 'Compression Resistance' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =0 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_bend_res = pm.floatSliderGrp ( label= 'Bend Resistance' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =0 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_twist_res = pm.floatSliderGrp ( label= 'Twist Resistance' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =0 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_curve_att = pm.floatSliderGrp ( label= 'Start Curve Attraction' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =0 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_curve_att_damp = pm.floatSliderGrp ( label= 'Atrraction Damp' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =0 , fieldMaxValue = 200.0 , value= 0 , precision = 3 , step = 0.01 )
global floatFieldEntry_joint_size
global floatFieldEntry_stretch_res
global floatFieldEntry_compress_res
global floatFieldEntry_bend_res
global floatFieldEntry_twist_res
global floatFieldEntry_curve_att
global floatFieldEntry_curve_att_damp
floatFieldEntry_joint_size = self.floatFieldEntry_joint_size
floatFieldEntry_stretch_res = self.floatFieldEntry_stretch_res
floatFieldEntry_compress_res = self.floatFieldEntry_compress_res
floatFieldEntry_bend_res = self.floatFieldEntry_bend_res
floatFieldEntry_twist_res = self.floatFieldEntry_twist_res
floatFieldEntry_curve_att = self.floatFieldEntry_curve_att
floatFieldEntry_curve_att_damp = self.floatFieldEntry_curve_att_damp
pm.button( label="Change Attritbute", width=400, command = dyn_curve_attr )
pm.separator( h=5, style='none')
pm.button( label="Low Resistance", width=400, command = dyn_curve_attr_rough_low )
pm.button( label="Medium Resistance", width=400, command = dyn_curve_attr_rough_medium )
pm.button( label="High Resistance", width=400, command = dyn_curve_attr_rough_high )
pm.separator( h=10, style='none')
pm.text('-'*100)
pm.text( 'Nucleus Properties' )
pm.text(' ')
self.floatFieldEntry_gravity = pm.floatSliderGrp ( label= 'Gravity' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 9.8 )
self.floatFieldEntry_gravityDirectionX = pm.floatSliderGrp ( label= 'Gravity DirectionX' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_gravityDirectionY = pm.floatSliderGrp ( label= 'Gravity DirectionY' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= -1 )
self.floatFieldEntry_gravityDirectionZ = pm.floatSliderGrp ( label= 'Gravity DirectionZ' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_airDensity = pm.floatSliderGrp ( label= 'Air Density' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 1 )
self.floatFieldEntry_windSpeed = pm.floatSliderGrp ( label= 'Wind Speed' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_windDirectionX = pm.floatSliderGrp ( label= 'Wind Direction X' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 1 )
self.floatFieldEntry_windDirectionY = pm.floatSliderGrp ( label= 'Wind Direction Y' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_windDirectionZ = pm.floatSliderGrp ( label= 'Wind Direction Z' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_windNoise = pm.floatSliderGrp ( label= 'Wind Noise' , field= True , minValue = -200 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 0 )
self.floatFieldEntry_maxCollisionIterations = pm.floatSliderGrp ( label= 'Max Collision Iterations' , field= True , minValue = 0 , maxValue =200.0 , fieldMinValue =-200 , fieldMaxValue = 200.0 , value= 4 )
global floatFieldEntry_gravity
global floatFieldEntry_gravityDirectionX
global floatFieldEntry_gravityDirectionY
global floatFieldEntry_gravityDirectionZ
global floatFieldEntry_airDensity
global floatFieldEntry_windSpeed
global floatFieldEntry_windDirectionX
global floatFieldEntry_windDirectionY
global floatFieldEntry_windDirectionZ
global floatFieldEntry_windNoise
global floatFieldEntry_maxCollisionIterations
floatFieldEntry_gravity = self.floatFieldEntry_gravity
floatFieldEntry_gravityDirectionX = self.floatFieldEntry_gravityDirectionX
floatFieldEntry_gravityDirectionY = self.floatFieldEntry_gravityDirectionY
floatFieldEntry_gravityDirectionZ = self.floatFieldEntry_gravityDirectionZ
floatFieldEntry_airDensity = self.floatFieldEntry_airDensity
floatFieldEntry_windSpeed = self.floatFieldEntry_windSpeed
floatFieldEntry_windDirectionX = self.floatFieldEntry_windDirectionX
floatFieldEntry_windDirectionY = self.floatFieldEntry_windDirectionY
floatFieldEntry_windDirectionZ = self.floatFieldEntry_windDirectionZ
floatFieldEntry_windNoise = self.floatFieldEntry_windNoise
floatFieldEntry_maxCollisionIterations = self.floatFieldEntry_maxCollisionIterations
pm.button( label="Change Attritbute", width=400, command= dyn_nucleus_attr )
pm.button( label="Default", width=400, command= dyn_nucleus_attr_default )
pm.scriptJob(e = [ 'SelectionChanged' , self.changing_properties ], cu = True, parent= 'hair_window')
window.show()
window_creation()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.