import hou
def findOfInput(node):
node_and_index = [None, None, 1]
hasfind = 1
node.allowEditingOfContents(1)
if len(node.children()):
for child in node.children():
if child.type().name() == 'output':
if child.parm('contexttype').eval() == 'surface':
inputs = child.inputConnectors()
if len(inputs[1]):
temp = inputs[1][0]
inputnode = temp.inputNode()
inputindex = temp.outputIndex()
node_and_index[0] = inputnode
node_and_index[1] = inputindex
else:
hasfind = 0
else:
hasfind = 0
node_and_index[2] = hasfind
return node_and_index
def checkVolume(node):
findvol = 0
if len(node.children()):
for child in node.children():
typename = child.type().name()
if typename == 'volumemodel' or typename == 'volumeshadercore' or typename == 'pyroshadercore':
findvol = 1
return findvol
def findrenderpass(node):
findresult = [0,
0,
0,
0,
0,
0]
if len(node.children()):
for child in node.children():
if child.type().name() == 'parameter':
parmname = child.parm('parmname').eval()
if parmname == 'my_id':
findresult[0] = 1
elif parmname == 'vol_Depth':
findresult[1] = 1
elif parmname == 'my_world_N':
findresult[2] = 1
elif parmname == 'my_cam_N':
findresult[3] = 1
elif parmname == 'vol_vel':
findresult[4] = 1
elif parmname == 'vol_N':
findresult[5] = 1
return findresult
def createVolPassNode(of_input, node, findresult):
inputnode = of_input[0]
inputindx = of_input[1]
node.allowEditingOfContents(1)
pos = inputnode.position()
pos[0] += 20
pos[1] -= 10
if not findresult[0]:
para_vel = node.createNode('parameter')
id_mul = para_vel.createOutputNode('multiply')
id_mul.setPosition(pos)
bind_vel = id_mul.createOutputNode('parameter')
id_mul.setNextInput(inputnode, inputindx)
para_vel.parm('parmname').set('my_id')
para_vel.parm('parmtype').set(7)
para_vel.parm('invisible').set(1)
para_vel.setPosition(id_mul.position())
para_vel.move([-3, 0])
bind_vel.setPosition(id_mul.position())
bind_vel.move([4, 0])
bind_vel.parm('parmname').set('my_id')
bind_vel.parm('parmtype').set(7)
bind_vel.parm('useasparmdefiner').set(1)
bind_vel.parm('exportparm').set(1)
bind_vel.parm('invisible').set(1)
bind_vel.setFirstInput(id_mul)
if not findresult[1]:
depth_global = node.createNode('global')
depth_mul = node.createNode('multiply')
depth_out = node.createNode('parameter')
depth_mul.setPosition(pos)
depth_mul.move([0, -3])
depth_mul.setInput(0, depth_global, 0)
depth_mul.setNextInput(inputnode, inputindx)
depth_global.setPosition(depth_mul.position())
depth_global.move([-3, 0])
depth_global.parm('usemenu').set(1)
depth_global.parm('varname').set('Pz')
depth_out.setPosition(depth_mul.position())
depth_out.move([4, 0])
depth_out.parm('parmname').set('vol_Depth')
depth_out.parm('parmtype').set('vector')
depth_out.parm('useasparmdefiner').set(1)
depth_out.parm('exportparm').set(1)
depth_out.parm('invisible').set(1)
depth_out.setInput(0, depth_mul, 0)
if not findresult[2]:
cn_out = node.createNode('parameter')
cn_mul = cn_out.createInputNode(0, 'multiply')
cn_ftv = cn_mul.createInputNode(0, 'floattovec')
cn_vtfx = cn_ftv.createInputNode(0, 'vectofloat')
cn_filterx = cn_vtfx.createInputNode(0, 'filtershadow')
cn_mulx = cn_filterx.createInputNode(1, 'multiply')
cn_transx = cn_mulx.createInputNode(0, 'transform')
cn_dirx = cn_transx.createInputNode(0, 'constant', 'dirx')
filter_distance = cn_mulx.createInputNode(1, 'parameter', 'filer_distance')
cn_vtfy = cn_ftv.createInputNode(1, 'vectofloat')
cn_filtery = cn_vtfy.createInputNode(0, 'filtershadow')
cn_muly = cn_filtery.createInputNode(1, 'multiply')
cn_transy = cn_muly.createInputNode(0, 'transform')
cn_diry = cn_transy.createInputNode(0, 'constant', 'dirx')
cn_vtfz = cn_ftv.createInputNode(2, 'vectofloat')
cn_filterz = cn_vtfz.createInputNode(0, 'filtershadow')
cn_mulz = cn_filterz.createInputNode(1, 'multiply')
cn_transz = cn_mulz.createInputNode(0, 'transform')
cn_dirz = cn_transz.createInputNode(0, 'constant', 'dirx')
cn_mul.setPosition(pos)
cn_mul.move([0, -14])
cn_ftv.setPosition(cn_mul.position())
cn_ftv.move([-3, 0])
cn_vtfx.setPosition(cn_ftv.position())
cn_vtfx.move([-3, 0])
cn_filterx.setPosition(cn_vtfx.position())
cn_filterx.move([-3, 0])
cn_mulx.setPosition(cn_filterx.position())
cn_mulx.move([-3, 0])
cn_transx.setPosition(cn_mulx.position())
cn_transx.move([-3, 0])
cn_transx.setPosition(cn_mulx.position())
cn_transx.move([-3, 0])
cn_dirx.setPosition(cn_transx.position())
cn_dirx.move([-3, 0])
cn_vtfy.setPosition(cn_ftv.position())
cn_vtfy.move([-3, -3])
cn_filtery.setPosition(cn_vtfy.position())
cn_filtery.move([-3, 0])
cn_muly.setPosition(cn_filtery.position())
cn_muly.move([-3, 0])
cn_transy.setPosition(cn_muly.position())
cn_transy.move([-3, 0])
cn_diry.setPosition(cn_transy.position())
cn_diry.move([-3, 0])
cn_vtfz.setPosition(cn_ftv.position())
cn_vtfz.move([-3, -6])
cn_filterz.setPosition(cn_vtfz.position())
cn_filterz.move([-3, 0])
cn_mulz.setPosition(cn_filterz.position())
cn_mulz.move([-3, 0])
cn_transz.setPosition(cn_mulz.position())
cn_transz.move([-3, 0])
cn_dirz.setPosition(cn_transz.position())
cn_dirz.move([-3, 0])
cn_mulx.setInput(1, filter_distance, 0)
cn_muly.setInput(1, filter_distance, 0)
cn_mulz.setInput(1, filter_distance, 0)
cn_dirx.parm('consttype').set('vector')
cn_dirx.parm('vectordef1').set(1)
cn_diry.parm('consttype').set('vector')
cn_diry.parm('vectordef2').set(1)
cn_dirz.parm('consttype').set('vector')
cn_dirz.parm('vectordef3').set(1)
cn_transx.parm('function').set('vtransform')
cn_transx.parm('fromspace').set('space:camera')
cn_transx.parm('tospace').set('space:world')
cn_transy.parm('function').set('vtransform')
cn_transy.parm('fromspace').set('space:camera')
cn_transy.parm('tospace').set('space:world')
cn_transz.parm('function').set('vtransform')
cn_transz.parm('fromspace').set('space:camera')
cn_transz.parm('tospace').set('space:world')
cn_out.setPosition(cn_mul.position())
cn_out.move([4, 0])
cn_out.parm('parmname').set('my_world_N')
cn_out.parm('parmtype').set('vector')
cn_out.parm('useasparmdefiner').set(1)
cn_out.parm('exportparm').set(1)
cn_out.parm('invisible').set(1)
cn_mul.setNextInput(inputnode, inputindx)
cn_out.setInput(0, cn_mul, 0)
filter_distance.setPosition(cn_mulx.position())
filter_distance.move([-12, -3])
filter_distance.parm('parmname').set('filter_distance')
filter_distance.parm('floatdef').set(1)
if not findresult[3]:
wn_out = node.createNode('parameter')
wn_mul = wn_out.createInputNode(0, 'multiply')
wn_ftv = wn_mul.createInputNode(0, 'floattovec')
wn_vtfx = wn_ftv.createInputNode(0, 'vectofloat')
wn_filterx = wn_vtfx.createInputNode(0, 'filtershadow')
wn_mulx = wn_filterx.createInputNode(1, 'multiply')
wn_dirx = wn_mulx.createInputNode(0, 'constant', 'dirx')
filter_distance = wn_mulx.createInputNode(1, 'parameter', 'filer_distance')
wn_vtfy = wn_ftv.createInputNode(1, 'vectofloat')
wn_filtery = wn_vtfy.createInputNode(0, 'filtershadow')
wn_muly = wn_filtery.createInputNode(1, 'multiply')
wn_diry = wn_muly.createInputNode(0, 'constant', 'diry')
wn_vtfz = wn_ftv.createInputNode(2, 'vectofloat')
wn_filterz = wn_vtfz.createInputNode(0, 'filtershadow')
wn_mulz = wn_filterz.createInputNode(1, 'multiply')
wn_dirz = wn_mulz.createInputNode(0, 'constant', 'dirz')
wn_mul.setPosition(pos)
wn_mul.move([0, -6])
wn_ftv.setPosition(wn_mul.position())
wn_ftv.move([-3, 0])
wn_vtfx.setPosition(wn_ftv.position())
wn_vtfx.move([-3, 0])
wn_filterx.setPosition(wn_vtfx.position())
wn_filterx.move([-3, 0])
wn_mulx.setPosition(wn_filterx.position())
wn_mulx.move([-3, 0])
wn_dirx.setPosition(wn_mulx.position())
wn_dirx.move([-3, 0])
filter_distance.setPosition(wn_dirx.position())
filter_distance.move([-10, -3])
wn_vtfy.setPosition(wn_ftv.position())
wn_vtfy.move([-3, -3])
wn_filtery.setPosition(wn_vtfy.position())
wn_filtery.move([-3, 0])
wn_muly.setPosition(wn_filtery.position())
wn_muly.move([-3, 0])
wn_diry.setPosition(wn_muly.position())
wn_diry.move([-3, 0])
wn_vtfz.setPosition(wn_ftv.position())
wn_vtfz.move([-3, -6])
wn_filterz.setPosition(wn_vtfz.position())
wn_filterz.move([-3, 0])
wn_mulz.setPosition(wn_filterz.position())
wn_mulz.move([-3, 0])
wn_dirz.setPosition(wn_mulz.position())
wn_dirz.move([-3, 0])
wn_dirx.parm('consttype').set('vector')
wn_dirx.parm('vectordef1').set(1)
wn_diry.parm('consttype').set('vector')
wn_diry.parm('vectordef2').set(1)
wn_dirz.parm('consttype').set('vector')
wn_dirz.parm('vectordef3').set(1)
filter_distance.parm('parmname').set('filter_distance1')
filter_distance.parm('floatdef').set(1)
wn_muly.setInput(1, filter_distance, 0)
wn_mulz.setInput(1, filter_distance, 0)
wn_out.setPosition(wn_mul.position())
wn_out.move([4, 0])
wn_out.parm('parmname').set('my_cam_N')
wn_out.parm('parmtype').set('vector')
wn_out.parm('useasparmdefiner').set(1)
wn_out.parm('exportparm').set(1)
wn_out.parm('invisible').set(1)
wn_mul.setNextInput(inputnode, inputindx)
wn_out.setInput(0, wn_mul, 0)
if not findresult[4]:
vel_in = node.createNode('parameter')
vel_mul = node.createNode('multiply')
vel_out = node.createNode('parameter')
vel_mul.setPosition(pos)
vel_mul.move([0, 2])
vel_mul.setInput(0, vel_in, 0)
vel_mul.setNextInput(inputnode, inputindx)
vel_in.setPosition(vel_mul.position())
vel_in.move([-3, 0])
vel_in.parm('parmname').set('vel')
vel_in.parm('parmtype').set('vector')
vel_in.parm('invisible').set(1)
vel_out.setPosition(vel_mul.position())
vel_out.move([4, 0])
vel_out.parm('parmname').set('vol_vel')
vel_out.parm('parmtype').set('vector')
vel_out.parm('useasparmdefiner').set(1)
vel_out.parm('exportparm').set(1)
vel_out.parm('invisible').set(1)
vel_out.setInput(0, vel_mul, 0)
if not findresult[5]:
myN_mul = node.createNode('multiply')
myN_out = node.createNode('parameter')
myN_mul.setPosition(pos)
myN_mul.move([0, 5])
trans = myN_mul.createInputNode(0, 'transform')
normalize = trans.createInputNode(0, 'normalize')
inline = normalize.createInputNode(0, 'inline')
density = inline.createInputNode(0, 'parameter', 'density')
trans.parm('function').set('ntransform')
trans.parm('tospace').set('space:object')
inline.parm('code').set('$nor = gradient($density)*-1;')
inline.parm('outtype1').set('vector')
inline.parm('outname1').set('nor')
inline.parm('outlabel1').set('$nor')
density.parm('parmname').set('density')
density.parm('floatdef').set(1)
density.parm('invisible').set(1)
myN_out.setPosition(myN_mul.position())
myN_out.move([4, 0])
myN_out.parm('parmname').set('vol_N')
myN_out.parm('parmtype').set('vector')
myN_out.parm('useasparmdefiner').set(1)
myN_out.parm('exportparm').set(1)
myN_out.parm('invisible').set(1)
myN_out.setInput(0, myN_mul, 0)
myN_mul.setNextInput(inputnode, inputindx)
def main():
nodes = hou.selectedNodes()
if len(nodes):
for node in nodes:
of_input = findOfInput(node)
if of_input[2]:
findresult = findrenderpass(node)
if findresult[0]:
print('%s中已经存在my_id的输出节点啦~~！' % node.path())
if findresult[1]:
print('%s中已经存在vol_Depth的输出节点啦~~！！' % node.path())
if findresult[1]:
print('%s中已经存在my_world_N的输出节点啦~~！！' % node.path())
if findresult[1]:
print('%s中已经存在my_cam_N的输出节点啦~~！！' % node.path())
if findresult[1]:
print('%s中已经存在vol_vel的输出节点啦~~！！' % node.path())
if findresult[1]:
print('%s中已经存在my_N的输出节点啦~~！！' % node.path())
result = findresult[0] + findresult[1] + findresult[2] + findresult[3] + findresult[4] + findresult[5]
if result != 6:
createVolPassNode(of_input, node, findresult)
print('完成')
else:
print('没有找到Of的输入端，请先检查下材质')
else:
print('没有指定材质节点，所有材质的体积分层都帮你加上啦~~！！')
