def __init__(self, node, rig_subnet):
print "muscle"
self.node = node
self.rig_subnet = rig_subnet
self.limb_subnet = self.create_rig_node(self.rig_subnet)
self.node_rename(self.node, self.limb_subnet)
self.make_color(self.node)
self.colorize_node(self.limb_subnet, self.color)
self.position_node(self.node, self.limb_subnet)
#todo put all this into smaller functions
copy_self_node = hou.copyNodesTo([self.node], self.node.parent())
copy_self_node = copy_self_node[0]
copy_self_node.node("fetch_parent").destroy()
copy_self_node.node("fetch_parent1").destroy()
hou.copyNodesTo(copy_self_node.children(), self.limb_subnet)
copy_self_node.destroy()
# creating the nodes into variables--------------------------------------------------------------
fetch = self.create_fetch_import(self.node.parm("hook"), self.limb_subnet)
fetch_upper = self.create_fetch_import(self.node.parm("hook_upper"), self.limb_subnet)
list_of_fetchers = [fetch, fetch_upper]
self.o_position = self.limb_subnet.node("origin_position")
self.i_position = self.limb_subnet.node("insertion_position")
self.center_offset = self.limb_subnet.node("center_offset")
self.muscle_node = self.limb_subnet.node("muscle")
self.chop_muscle = self.limb_subnet.node("chopnet_muscle")
self.jiggle_switch_node = self.chop_muscle.node("switch_jiggle_effect")
self.jiggle_node = self.chop_muscle.node("jiggle_center_muscle")
list_of_positioners = [self.o_position, self.i_position]
for index, i in enumerate(list_of_positioners):
# i.parm("keeppos").set(0)
i.setInput(0, list_of_fetchers[index])
# i.parm("keeppos").set(1)
self.limb_subnet.layoutChildren()
muscle_node = self.limb_subnet.node("muscle")
muscle_node.parm("tdisplay").set(1)
try:
muscle_node_position = muscle_node.position()
chop_node = self.limb_subnet.node("chopnet_muscle")
chop_node.setPosition([muscle_node_position[0], (muscle_node_position[1]-.5)])
except:
pass
self.muscle_view()
self.promote_parms(self.rig_subnet, ["Rig Parms", self.node.name()])
self.promote_viz_positioners()
gv.muscle_deformers_list.append(muscle_node)
def create_snippet_network(self):
"""Create snippet subnetwork at /obj level for user selection."""
selection = utils_hou.get_selection(1)
if not selection:
hou.ui.displayMessage("Please select nodes to send.")
return
obj_context = hou.node("/obj")
selection_type = selection[0].type().category().name()
snippet_name_prompt = hou.ui.readInput("Enter snippet name:",
("OK", "Cancel"))
input_name = snippet_name_prompt[1]
input_name = input_name.replace(" ", "_")
snippet_name = "snp_" + input_name
if not snippet_name:
hou.ui.displayMessage("Please enter a snippet name")
return
snippet_subnet = obj_context.createNode("subnet",
node_name=snippet_name)
snippet_subnet.setColor(hou.Color(0.97, 0.78, 0.26))
snippet_subnet.setDisplayFlag(False)
if utils_hou.HOU_VER >= 16:
snippet_subnet.setUserData("nodeshape", "circle")
destination_node = snippet_subnet
if selection_type == "Sop":
destination_node = snippet_subnet.createNode("geo")
destination_node.setName("container_" + input_name)
if selection_type == "Vop":
destination_node = snippet_subnet.createNode("matnet")
destination_node.setName("container_" + input_name)
if selection_type == "Driver":
destination_node = snippet_subnet.createNode("ropnet")
destination_node.setName("container_" + input_name)
snippet_verif = snippet_subnet.createNode("subnet")
snippet_verif.setName("snippet_verification")
snippet_verif.setDisplayFlag(False)
snippet_verif.hide(True)
destination_node.setColor(hou.Color(0, 0, 0))
hou.copyNodesTo(selection, destination_node)
def bakeObjectToWorld(startFrame, endFrame):
selectedNode = hou.selectedNodes()
selectedNodeName = selectedNode[0].name()
parent = selectedNode[0].parent()
bakeNode = hou.copyNodesTo(selectedNode, parent)
bakeNode[0].setName(selectedNodeName + "_bake")
bakeNode[0].parm("keeppos").set(0)
fetchNode = hou.node(parent.path()).createNode("fetch",
"fetch_" + selectedNodeName)
hou.node(fetchNode.path()).parm("fetchobjpath").set(selectedNode[0].path())
hou.node(fetchNode.path()).parm("useinputoffetched").set(1)
nullNode = hou.node(parent.path()).createNode("null")
nullNode.setFirstInput(fetchNode)
nullNodeName = nullNode.name()
parms = ["tx", "ty", "tz", "rx", "ry", "rz"]
constant = ["TX", "TY", "TZ", "RX", "RY", "RZ"]
bakeNode[0].setInput(0, None)
#delete expresssion in parms and set to 0
for p in parms:
bakeNode[0].parm(p).deleteAllKeyframes()
hou.hscript('objextractpretransform ' + bakeNode[0].path())
bakeNode[0].parm(p).set(0)
for p, c in zip(parms, constant):
#bakeNode[0].parm(p).deleteAllKeyframes()
hou.node(bakeNode[0].path()).parm(p).setExpression('origin("","../' +
nullNodeName +
'",' + c + ')')
#add dict for hou.Keyframe and values
key = dict([(x, hou.Keyframe()) for x in parms])
values = dict([(x, []) for x in constant])
#bake time range
timeRange = xrange(startFrame, endFrame + 1)
#fill values dict
for t in timeRange:
hou.setFrame(t)
for v, p in zip(constant, parms):
values[v].append(bakeNode[0].parm(p).eval())
for p in parms:
bakeNode[0].parm(p).deleteAllKeyframes()
bakeNode[0].parm(p).set(0)
#set key by keyframes
for t in timeRange:
hou.setFrame(t)
for v, p, k in zip(constant, parms, key):
key[k].setValue(values[v][t - startFrame])
bakeNode[0].parm(p).setKeyframe(key[k])
fetchNode.destroy()
nullNode.destroy()
def CreateSetImportNode(filepath, indexx):
global node
global parentnode
global grandparentnode
global generatedNodes
global mergenode
fileimportnode = grandparentnode.createNode("file")
fileimportnode.parm('file').set(filepath)
templates = hou.copyNodesTo(nodestocopy, grandparentnode)
templates[0].setInput(0, fileimportnode, 0)
mergenode.setInput(indexx, templates[1], 0)
for nodeee in templates:
generatedNodes.append(nodeee)
generatedNodes.append(fileimportnode)
def SubMeshesSplitToGeos(submeshNode):
submeshNode.setHardLocked(True)
nodeName = submeshNode.name()
currentHomeNode = submeshNode.parent()
outWorld = currentHomeNode.parent()
newHomeNode = outWorld.createNode('geo')
newHomeNode.setName(nodeName,True)
currentHomeInputs = currentHomeNode.inputs()
if currentHomeInputs and len(currentHomeInputs) > 0:
BasicFunc.connect_node(currentHomeInputs[0], newHomeNode)
BasicFunc.alignWorldPos(newHomeNode, currentHomeNode)
BasicFunc.adjustLayout(newHomeNode)
cpNode = hou.copyNodesTo((submeshNode,), newHomeNode)[0]
submeshNode.setColor(hou.Color(1, 0, 0))
def changeWrangle():
nodes = hou.selectedNodes()
for node in nodes:
try:
mode = node.parm('mode').eval()
types = ['attribwrangle', 'volumewrangle', 'deformationwrangle']
wrangle = types[mode]
group_parm = 'group{}'.format('2' if mode == 1 else "")
group = node.parm(group_parm).eval()
snippet = 'snippet{}'.format(mode + 1)
code = node.parm(snippet).eval()
pcodes = [i.asCode() for i in node.parms()]
new_node = hou.copyNodesTo([node], node.parent())[0]
new_node = new_node.changeNodeType(wrangle)
pn = re.compile('.parm\(\"([^\)]+)\"\)')
for p in pcodes:
try:
exec(p)
except (AttributeError):
pname = pn.search(p).groups()[0]
print 'Can\'t set parm {}'.format(pname)
new_node.parm('group').set(group)
new_node.parm('snippet').set(code)
new_node.matchCurrentDefinition()
for i, inp in enumerate(node.inputs()):
new_node.setInput(i, inp)
for c in node.outputConnections():
out = c.outputNode()
i = c.inputIndex()
out.setInput(i, new_node)
name = node.name()
node.destroy()
new_node.setName(name)
new_node.setColor(hou.Color(colors.wrangle_new))
except (AttributeError):
hou.ui.displayMessage(
"{} is not an actionwrangle instance!".format(node.name()))
def subGeoVersion1(self, FBX, OBJ):
# Create Geometry node to store FBX parts
geometry = OBJ.createNode('geo', run_init_scripts=False)
geometry.setName('GEO_{}'.format(FBX.name()), unique_name=True)
geometry.moveToGoodPosition()
# Get all parts inside FBX container
geometry_FBX = [
node for node in FBX.children() if node.type().name() == 'geo'
]
# Create merge node for parts
merge = geometry.createNode('merge')
merge.setName('master_merge')
#Create Null Object at the end
oNull = geometry.createNode('null')
oNull.setName('OUT_DAZ')
#Link MergeOut to NullIn
oNull.setInput(0, merge)
####
for geo in geometry_FBX:
# Create Object Merge node
objectMerge = geometry.createNode('object_merge')
objectMerge.setName(geo.name())
# Set path to FBX part object
objectMerge.parm('objpath1').set(geo.path())
objectMerge.parm('xformtype').set(1)
## MATERIAL HANDLING
matName = hou.node("obj/" + FBX.name() + "/" + geo.name() + "/" +
geo.name() + "_material")
if matName is not None:
parentH = hou.node("obj/" + geometry.name())
hou.copyNodesTo([matName], parentH)
material = hou.node("obj/" + geometry.name() + "/" +
geo.name() + "_material")
############------------############
#Call process to convert materials.
#From Older Version Un-Implemented
############------------############
else:
# Create Material node if none exist. No materials are added if none are detected.
material = geometry.createNode('material')
material.setName('MAT_{}'.format(geo.name()))
# LINK NODES
# Link Material to Object MergeName
material.setNextInput(objectMerge)
# Link part to Merge
merge.setNextInput(material)
# Set Null Node flags to Render
oNull.setDisplayFlag(1)
oNull.setRenderFlag(1)
# Layout geometry content in Network View
geometry.layoutChildren()
####
# Set Null Node flags to Render
oNull.setDisplayFlag(1)
oNull.setRenderFlag(1)
# Layout geometry content in Network View
geometry.layoutChildren()
def __createBuildingNodes__(self):
# Inicialize for LoD function
firstNode = self.__geo__.children()[0]
firstNode.setSelected(True)
LoD.LoD_max().recorrer(LoD.connexioDescendent(),
LoD.obtenirNodesArrels().obtenir())
# Last added node(node from LoD import function) which contains the original building
originalBuilding = self.__geo__.children()[len(self.__geo__.children())
- 1]
originalBuilding.moveToGoodPosition()
# We create the condition node and connect it with the nodes
# which input nodes were connected
conditionNodeInserts = self.__geo__.createNode(
'destructionConditional')
conditionNodeInserts.setName('conditionNodeInserts', True)
conditionNodeGeneric = self.__geo__.createNode(
'destructionConditional')
conditionNodeGeneric.setName('conditionNodeGeneric', True)
mergeToInserts = self.__geo__.createNode('merge')
mergeToInserts.setName('mergeToInserts', True)
mergeFromGeneric = self.__geo__.createNode('merge')
mergeFromGeneric.setName('mergeFromGeneric', True)
fuseToInserts = self.__geo__.createNode('fuse')
fuseToInserts.setName('fuseToInserts', True)
fuseToInserts.parm('dist').set(0.01)
fuseFromGeneric = self.__geo__.createNode('fuse')
fuseFromGeneric.setName('fuseFromGeneric', True)
fuseFromGeneric.parm('dist').set(0.01)
conditionNodeInserts.moveToGoodPosition()
conditionNodeGeneric.moveToGoodPosition()
# pattern to find the correct parm in the "object_merge" node
# wich is the original building
pattern = nameParmObjPath + '[0-9]*'
patternCompiled = re.compile(pattern)
'''
Added and modified 19/05/2011
'''
geo = self.__geo__
listOfParmsGroup = self.__conditionGroupsParm__
# Create merge node
mergeNode = geo.createNode('merge')
mergeNode.setNextInput(conditionNodeInserts)
mergeNode.setNextInput(conditionNodeGeneric)
# Connect groupNode partDes shop to condition nodes
combineGroupPartDes = geo.createNode('group')
combineGroupPartDes.setNextInput(mergeNode)
# rename node
combineGroupPartDes.setName('combinedGroupPartDes', True)
# Connect groupNode totDes shop to groupPartDes node
combineGroupTotDes = geo.createNode('group')
combineGroupTotDes.setNextInput(combineGroupPartDes)
# rename node
combineGroupTotDes.setName('combinedGroupTotDes', True)
combineGroupNotDes = geo.createNode('group')
combineGroupNotDes.setNextInput(combineGroupTotDes)
# rename node
combineGroupNotDes.setName('combinedGroupNotDes', True)
totDesInsertName = conditionNodeInserts.evalParm(listOfParmsGroup[0])
partiDesInsertName = conditionNodeInserts.evalParm(listOfParmsGroup[1])
notDesInsertName = conditionNodeInserts.evalParm(listOfParmsGroup[2])
totDesGenericName = conditionNodeGeneric.evalParm(listOfParmsGroup[0])
partiDesGenericName = conditionNodeGeneric.evalParm(
listOfParmsGroup[1])
notDesGenericName = conditionNodeGeneric.evalParm(listOfParmsGroup[2])
# Inicialize combined groups
combineGroupPartDes.parm('crname').set('combinedPartDes')
combineGroupPartDes.parm('grpequal').set('combinedPartDes')
combineGroupPartDes.parm('grp1').set(partiDesInsertName)
combineGroupPartDes.parm('grp2').set(partiDesGenericName)
combineGroupPartDes.parm('op1').set('or')
combineGroupTotDes.parm('crname').set('combinedTotDes')
combineGroupTotDes.parm('grpequal').set('combinedTotDes')
combineGroupTotDes.parm('grp1').set(totDesInsertName)
combineGroupTotDes.parm('grp2').set(totDesGenericName)
combineGroupTotDes.parm('op1').set('or')
combineGroupNotDes.parm('crname').set('combinedNotDes')
combineGroupNotDes.parm('grpequal').set('combinedNotDes')
combineGroupNotDes.parm('grp1').set(notDesInsertName)
combineGroupNotDes.parm('grp2').set(notDesGenericName)
combineGroupNotDes.parm('op1').set('or')
labeler = self.__geo__.createNode('Labeler')
labeler.setNextInput(combineGroupNotDes)
'''
End modification 19/05/2011
'''
for parm in originalBuilding.parms():
if patternCompiled.match(parm.name()):
posibleNode = hou.node(parm.eval())
if posibleNode.type().name() == 'Insert':
logging.debug('INSERTS:' + str(posibleNode))
self.__inserts__.append(posibleNode)
tempInputs = posibleNode.inputs()
# we delete the connections from input nodes to not duplicated geometry
'''
Added and modified 12/05/2011, Labeler
'''
posibleNode.setInput(0, labeler, 0)
'''
End modification 12/05/2011, Labeler
'''
for i in range(len(tempInputs) - 1):
posibleNode.setInput(i + 1, None, 0)
for input in tempInputs:
# We have to ensure that "input" is not None(in houdini it's allowed None inputs) and not repeat
if input != None and input not in mergeToInserts.inputs(
):
mergeToInserts.setNextInput(input, 0)
fuseToInserts.setNextInput(mergeToInserts, 0)
conditionNodeInserts.setNextInput(fuseToInserts, 0)
mergeToInserts.moveToGoodPosition()
fuseToInserts.moveToGoodPosition()
conditionNodeInserts.moveToGoodPosition()
for output in conditionNodeInserts.outputs():
output.moveToGoodPosition()
# we create the nodes which will contain the destroyed building. They will be a copy
# of the original building, and later we will change some parameters to convert it to
# a destroyed building
# "group" of nodes to copy. We need only the original building, but, for houdini software reasons
# it must be a group.
tempGroup = [originalBuilding]
listPartsInserts = []
listPartsGeneric = []
for name in self.__listNamesInserts__:
tempNode = hou.copyNodesTo(tempGroup, originalBuilding.parent())[0]
tempNode.setName(name, True)
listPartsInserts.append(tempNode)
for name in self.__listNamesGeneric__:
tempNode = hou.copyNodesTo(tempGroup, originalBuilding.parent())[0]
tempNode.setName(name, True)
listPartsGeneric.append(tempNode)
originalBuilding.destroy()
# Create the final building node
finalBuilding = self.__geo__.createNode('merge')
finalBuilding.setName('finalBuilding', True)
finalBuilding.moveToGoodPosition()
# Connect the building inserts geometry(modified) with the final building
for node in listPartsInserts:
finalBuilding.setNextInput(node)
node.moveToGoodPosition()
# Connect the building general(no insert geometry) with the condition node especific for they
for node in listPartsGeneric:
mergeFromGeneric.setNextInput(node)
node.moveToGoodPosition()
fuseFromGeneric.setNextInput(mergeFromGeneric)
conditionNodeGeneric.setNextInput(fuseFromGeneric)
mergeFromGeneric.moveToGoodPosition()
fuseFromGeneric.moveToGoodPosition()
conditionNodeGeneric.moveToGoodPosition()
mergeNode.moveToGoodPosition()
labeler.moveToGoodPosition()
combineGroupPartDes.moveToGoodPosition()
combineGroupTotDes.moveToGoodPosition()
combineGroupNotDes.moveToGoodPosition()
# Finally connect the condition node of the general geometry to the final building
finalBuilding.setNextInput(labeler)
finalBuilding.moveToGoodPosition()
# Assign the data
self.__listPartsInserts__ = listPartsInserts
self.__listPartsGeneric__ = listPartsGeneric
self.__conditionNodeInserts__ = conditionNodeInserts
self.__conditionNodeGeneric__ = conditionNodeGeneric
self.__finalBuilding__ = finalBuilding
self.__labeler__ = labeler
def generateTextures(objNode):
print("OBJ: \"%s\"" % (objNode.path()))
vopTypes = hou.vopNodeTypeCategory().nodeTypes()
vrayVopTypes = sorted(
[vopType for vopType in vopTypes if vrayVopFilter(vopType)])
# FOR TESTS
# vrayVopTypes = vrayVopTypes[:2]
bbox = objNode.renderNode().geometry().boundingBox()
bboxWidth = bbox.sizevec().x()
bboxDepth = bbox.sizevec().z()
col = 0
row = 0
bboxOffsetPerc = 2.0
offsetX = bboxWidth * bboxOffsetPerc
offsetY = bboxDepth * bboxOffsetPerc
cellW = bboxWidth + offsetX
cellD = bboxDepth + offsetY
maxColCount = int(math.sqrt(len(vrayVopTypes)))
matNet = getCreateEmpty(MAT, "vray_material", "TEXTURES_ALL_PER_FRAME")
objNet = getCreateEmpty(OBJ, "subnet", "TEXTURES_ALL_PER_FRAME")
fontMat = getCreate(MAT, "VRayNodeBRDFVRayMtl", "font")
fontMat.setMaterialFlag(True)
fontMat.parm("diffuser").set(0.05)
fontMat.parm("diffuseg").set(0.05)
fontMat.parm("diffuseb").set(0.05)
uvw = matNet.createNode("VRayNodeUVWGenMayaPlace2dTexture",
node_name="channel_uv")
uvw.parm("repeat_u").set(3)
uvw.parm("repeat_v").set(3)
for texType in vrayVopTypes:
tex = None
texName = texType.replace(PREFIX, "")
try:
mtl = matNet.createNode("VRayNodeBRDFVRayMtl",
node_name="mtl%s" % texName)
# Attach texture to "diffuse".
tex = mtl.createInputNode(0, texType, node_name=texName)
uvwGenIndex = tex.inputIndex("uvwgen")
if uvwGenIndex >= 0:
tex.setNamedInput("uvwgen", uvw, 0)
except:
print("Failed: \"%s\"" % (texType))
if tex:
objForTex = getCreateEmpty(objNet, "geo", "obj%s" % texName)
# Copy source geo.
hou.copyNodesTo(objNode.children(), objForTex)
testMtl = objForTex.createNode("material")
testMtl.setNextInput(objForTex.renderNode())
# Assign material
objForTex.parm("shop_materialpath").set("")
testMtl.parm("shop_materialpath1").set(mtl.path())
# Add text
font = objForTex.createNode("font")
font.parm("file").set("Consolas")
font.parm("text").set(texName)
font.parm("fontsize").set(0.2)
fontDivide = objForTex.createNode("divide")
fontDivide.setNextInput(font)
fontExt = objForTex.createNode("polyextrude")
fontExt.parm("dist").set(0.02)
fontExt.setNextInput(fontDivide)
fontTm = objForTex.createNode("xform")
fontTm.setNextInput(fontExt)
fontTm.parm("tx").set(0.3)
fontTm.parm("rx").set(-90.0)
fontTm.parm("ry").set(90.0)
fontMtl = objForTex.createNode("material")
fontMtl.setNextInput(fontTm)
fontMtl.parm("shop_materialpath1").set(fontMat.path())
merge = objForTex.createNode("merge")
merge.setNextInput(testMtl)
merge.setNextInput(fontMtl)
merge.setDisplayFlag(True)
merge.setRenderFlag(True)
objForTex.layoutChildren()
pos = (row * cellD, 0, col * cellW)
tm = hou.hmath.buildTranslate(pos)
objForTex.setWorldTransform(tm)
if col == maxColCount - 1:
col = 0
row += 1
else:
col += 1
matNet.layoutChildren()
objNet.layoutChildren()
gltf_hierarchy_list = []
for nodes in my_network:
if nodes.type().name() == 'gltf_hierarchy':
gltf_hierarchy_list.append(nodes)
#create sub_geo for each glTF hierarchy in glTF_Loader
for nodes in gltf_hierarchy_list:
#create subnet to host all gltf nodes in the glTF_Loader
geo_node = glTF_Loader.createNode('subnet', nodes.name())
#find and list all geo node in glTF hierarchy
sub_geo = nodes.children()
for i in sub_geo:
geo_node_list = []
if i.type().name() == 'geo':
geo_node_list.append(i)
new_glTF_node = hou.copyNodesTo(geo_node_list, geo_node)[0]
GLTF = new_glTF_node.children()[0]
#get selection class hou.Geometry to find an Attribute value
geo = GLTF.geometry()
shd_Prim_Name = geo.findPrimAttrib("shop_materialpath")
value = shd_Prim_Name.strings()[0]
#get only shader name
shd_name = str(value.split("/")[-1])
new_shd_primattrib = 'setprimattrib(0, "shop_materialpath", @primnum, "/mat/' + shd_name + '","set");'
#create and set Rrim Wrangler to rename shop_materialpath attribute
wrang = new_glTF_node.createNode("attribwrangle",
"Set_New_Material_Path")
wrang.parm('class').set(1)
wrang.parm('snippet').set(new_shd_primattrib)
wrang.setFirstInput(GLTF)
#create normal node and set it to Face Area
def insertGraphSplit():
print "\n" * 2
print "_" * 100
print "Splitting PDG ImageMagick Montage..."
#hardcoded to 2 for now
num_splits = 2
#analyze PDG Graph and get Nodes into object
pdg_graph_obj = PDGGraphObject()
#reassign nodes
pdgchain_nodes = pdg_graph_obj._pdgchain_nodes
ffmpeg_node = pdg_graph_obj._ffmpeg_node
imagemagick_node = pdg_graph_obj._imagemagick_node
wedge_root_node = pdg_graph_obj._wedge_root_node
parent_topnet = wedge_root_node.parent()
render_node = pdg_graph_obj._render_node
render_node_pdg = pdg_graph_obj._render_node_pdg
#get wedge count from first root wedge node
root_wedge_count = wedge_root_node.parm("wedgecount").eval()
#create new split node and position
new_split_node = parent_topnet.createNode("split", "split_montage")
new_split_node.setPosition(render_node_pdg.position())
new_split_node.move([0, -2])
new_split_node.setInput(0, render_node_pdg)
split_expr = new_split_node.parm("splitexpression")
split_expr.setExpression("@wedgenum<" +
str((root_wedge_count / num_splits)))
#make sure ffmpeg node and image_magick node end with split postfix _p0, _p1
if not ffmpeg_node.name().endswith("_p0"):
ffmpeg_node.setName(ffmpeg_node.name() + "_p0")
if not imagemagick_node.name().endswith("_p0"):
imagemagick_node.setName(imagemagick_node.name() + "_p0")
#copy / paste remaining nodechain
old_nodes = []
old_nodes.append(ffmpeg_node)
for node in pdgchain_nodes:
#break loop before appending rende ropfetch node
if node == render_node_pdg:
break
#append
old_nodes.append(node)
new_nodes = hou.copyNodesTo(old_nodes, parent_topnet)
#move new stream
for node in new_nodes:
node.move([2, -2])
#set input
new_nodes[-1].setInput(0, new_split_node, 1)
#move old stream
for node in old_nodes:
node.move([-2, -2])
#set input
old_nodes[-1].setInput(0, new_split_node, 0)
print "_" * 100
print "Finished splitting PDG ImageMagick Montage successfully"
print "_" * 100
print "\n" * 2
def ConvertJointsToBones_Hierachy(rootNode):
#print 'parent:', rootNode.parent()
#rootNode.parent().createNode('null','testnull')
destroyList = []
stack = []
realBoneList = []
newNames = []
firstAuthority = []
subnet = rootNode.parent()
stack.append(rootNode)
BasicFunc.set_transform_keeppos(rootNode)
while len(stack) > 0:
nullNode = stack.pop()
# print nullNode
nodeInputs = nullNode.inputs()
hierachyParent = None
if nodeInputs is not None and len(nodeInputs) > 0:
hierachyParent = nodeInputs[0]
destroyList.append(nullNode)
firstFlag = True
nullNodeOutputs = nullNode.outputs()
if nullNodeOutputs is not None and len(nullNodeOutputs) > 0:
for child in nullNode.outputs():
BasicFunc.set_transform_keeppos(child)
childTypeName = child.type().name()
# print childTypeName
if childTypeName == 'null':
#print 'append', child
stack.append(child)
elif childTypeName == 'bone':
#child 是替代骨骼
nodeLookAt = child.node(child.parm('lookatpath').eval())
BasicFunc.set_transform_keeppos(nodeLookAt)
# create bone node and parent to origin parent
realBoneNode = subnet.createNode('bone')
realBoneList.append(realBoneNode)
#append !!!!!
newNames.append(nullNode.name())
if firstFlag:
firstFlag = False
firstAuthority.append(True)
else:
firstAuthority.append(False)
realBoneNode.parm('length').set(child.parm('length').eval())
realBoneNode.setColor(hou.Color(1, 0, 0))
BasicFunc.connect_node(child, realBoneNode)
BasicFunc.alignWorldPos(realBoneNode, nullNode)
realBoneNode.parm('keeppos').set(True)
BasicFunc.adjustLayout(realBoneNode)
if hierachyParent:
BasicFunc.connect_node(hierachyParent, realBoneNode)
else:
realBoneNode.setInput(0, None, 0)
BasicFunc.connect_node(realBoneNode,nodeLookAt)
destroyList.append(child)
else:
endBoneNode = subnet.createNode('bone')
BasicFunc.connect_node(nullNode, endBoneNode)
endBoneNode.parm('length').set(0)
BasicFunc.adjustLayout(endBoneNode)
BasicFunc.alignWorldPos(endBoneNode, nullNode)
endBoneNode.parm('keeppos').set(True)
realBoneList.append(endBoneNode)
newNames.append(nullNode.name())
firstAuthority.append(True)
for deadNode in destroyList:
deadNode.destroy()
for i in range(len(realBoneList)):
if firstAuthority[i]:
realBoneList[i].setName(newNames[i],True)
else:
realBoneList[i].setName(newNames[i]+'_00', True)
for geoNode in subnet.children():
if geoNode.type().name() == 'geo':
# find bone capture node
currentRenderNode = geoNode.renderNode()
captureNode = None
for insideNode in geoNode.children():
# print insideNode
if insideNode.type().name() == 'capture':
captureNode = insideNode
break
if captureNode:
print 'capture node:', captureNode
cpNode = hou.copyNodesTo((captureNode,), geoNode)[0]
cpNode.setHardLocked(False)
attrCopyNode = geoNode.createNode('attribcopy')
BasicFunc.connect_node(cpNode, attrCopyNode,0,0)
BasicFunc.connect_node(captureNode, attrCopyNode,0,1)
attrCopyNode.parm('attribname').set('*')
BasicFunc.connect_node(attrCopyNode, currentRenderNode)
def charAssetsToHDA():
this = hou.node('.')
importNode = hou.hipFile.importFBX(this.parm('char_fbx_file').eval(), suppress_save_prompt=True, merge_into_scene=True, import_cameras=False, import_joints_and_skin=True, import_geometry=True, import_lights=False, import_animation=False, import_materials=False, resample_animation=False, resample_interval=1.0, override_framerate=False,framerate=-1, hide_joints_attached_to_skin=True, convert_joints_to_zyx_rotation_order=False, material_mode=hou.fbxMaterialMode.FBXShaderNodes, compatibility_mode=hou.fbxCompatibilityMode.Maya, single_precision_vertex_caches=False, triangulate_nurbs=False, triangulate_patches=False, import_global_ambient_light=False, import_blend_deformers_as_blend_sops=False, segment_scale_already_baked_in=True, convert_file_paths_to_relative=False, unlock_geometry=True, unlock_deformations=True, import_nulls_as_subnets=False, import_into_object_subnet=True, convert_into_y_up_coordinate_system=False)
fbxNode = importNode[0]
if fbxNode:
# set up the parameters
# CHOP mocap params
hou_parm_template = hou.StringParmTemplate("fbxfile", "FBX File", 1, default_value=([""]), naming_scheme=hou.parmNamingScheme.Base1, string_type=hou.stringParmType.FileReference, menu_items=([]), menu_labels=([]), icon_names=([]), item_generator_script="", item_generator_script_language=hou.scriptLanguage.Python, menu_type=hou.menuType.StringReplace)
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Character']), create_missing_folders=True)
hou_parm_template = hou.StringParmTemplate("fbxclip", "Clip", 1, default_value=([""]), naming_scheme=hou.parmNamingScheme.Base1, string_type=hou.stringParmType.Regular, menu_items=([]), menu_labels=([]), icon_names=([]), item_generator_script="opmenu -l CHOP/fbxagent/fbximport currentclip", item_generator_script_language=hou.scriptLanguage.Hscript, menu_type=hou.menuType.Normal)
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Character']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("mocapswitch", "Use Mocap?", default_value=False)
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Character']), create_missing_folders=True)
# Alembic params
hou_parm_template = hou.LabelParmTemplate("labelparm", "Alembic", column_labels=([""]))
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("use_cache", "Use Cache", default_value=False)
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.FloatParmTemplate("cache_scale", "Cache Scale", 1, default_value=([1]), min=0, max=10, min_is_strict=False, max_is_strict=False, look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.Base1)
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.MenuParmTemplate("trange", "Valid Frame Range", menu_items=(["off","normal","on"]), menu_labels=(["Render Current Frame","Render Frame Range","Render Frame Range Only (Strict)"]), default_value=0, icon_names=([]), item_generator_script="", item_generator_script_language=hou.scriptLanguage.Python, menu_type=hou.menuType.Normal)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.FloatParmTemplate("f", "Start/End/Inc", 3, default_value=([0, 0, 1]), default_expression=(["$FSTART","$FEND",""]), default_expression_language=([hou.scriptLanguage.Hscript,hou.scriptLanguage.Hscript,hou.scriptLanguage.Hscript]), min=0, max=10, min_is_strict=False, max_is_strict=False, look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.Base1)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.StringParmTemplate("cachefile", "Cache File", 1, default_value=(["$HIP/output.abc"]), naming_scheme=hou.parmNamingScheme.Base1, string_type=hou.stringParmType.FileReference, menu_items=([]), menu_labels=([]), icon_names=([]), item_generator_script="opmenu -l exportnet/alembic filename", item_generator_script_language=hou.scriptLanguage.Hscript, menu_type=hou.menuType.StringReplace)
hou_parm_template.setTags({"autoscope": "0000000000000000", "filechooser_pattern": "*.abc"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ButtonParmTemplate("cache_btn", "Cache to Disk")
hou_parm_template.setTags({"autoscope": "0000000000000000", "takecontrol": "always"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
#FBX params
hou_parm_template = hou.SeparatorParmTemplate("sepparm")
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.LabelParmTemplate("labelparm2", "FBX", column_labels=([""]))
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.MenuParmTemplate("trange2", "Valid Frame Range", menu_items=(["off","normal","on"]), menu_labels=(["Render Current Frame","Render Frame Range","Render Frame Range Only (Strict)"]), default_value=0, icon_names=([]), item_generator_script="", item_generator_script_language=hou.scriptLanguage.Python, menu_type=hou.menuType.Normal)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.FloatParmTemplate("f4", "Start/End/Inc", 3, default_value=([0, 0, 1]), default_expression=(["$FSTART","$FEND",""]), default_expression_language=([hou.scriptLanguage.Hscript,hou.scriptLanguage.Hscript,hou.scriptLanguage.Hscript]), min=0, max=10, min_is_strict=False, max_is_strict=False, look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.Base1)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.StringParmTemplate("take", "Render With Take", 1, default_value=(["_current_"]), naming_scheme=hou.parmNamingScheme.Base1, string_type=hou.stringParmType.Regular, menu_items=([]), menu_labels=([]), icon_names=([]), item_generator_script="opmenu -l exportnet/filmboxfbx1 take", item_generator_script_language=hou.scriptLanguage.Hscript, menu_type=hou.menuType.Normal)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.StringParmTemplate("sopoutput", "Output File", 1, default_value=(["$HIP/out.fbx"]), naming_scheme=hou.parmNamingScheme.Base1, string_type=hou.stringParmType.FileReference, menu_items=([]), menu_labels=([]), icon_names=([]), item_generator_script="opmenu -l exportnet/filmboxfbx1 sopoutput", item_generator_script_language=hou.scriptLanguage.Hscript, menu_type=hou.menuType.StringReplace)
hou_parm_template.setTags({"autoscope": "0000000000000000", "filechooser_mode": "write"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("mkpath", "Create Intermediate Directories", default_value=True, default_expression='on', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("exportkind", "Export in ASCII Format", default_value=True, default_expression='on', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.StringParmTemplate("sdkversion", "FBX SDK Version", 1, default_value=([""]), naming_scheme=hou.parmNamingScheme.Base1, string_type=hou.stringParmType.Regular, menu_items=([]), menu_labels=([]), icon_names=([]), item_generator_script="opmenu -l exportnet/filmboxfbx1 sdkversion", item_generator_script_language=hou.scriptLanguage.Hscript, menu_type=hou.menuType.Normal)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.MenuParmTemplate("vcformat", "Vertex Cache Format", menu_items=(["mayaformat","maxformat"]), menu_labels=(["Maya Compatible (MC)","3DS MAX Compatible (PC2)"]), default_value=0, icon_names=([]), item_generator_script="", item_generator_script_language=hou.scriptLanguage.Python, menu_type=hou.menuType.Normal)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.MenuParmTemplate("invisobj", "Export Invisible Objects", menu_items=(["nullnodes","fullnodes"]), menu_labels=(["As Hidden Null Nodes","As Hidden Full Nodes"]), default_value=0, icon_names=([]), item_generator_script="", item_generator_script_language=hou.scriptLanguage.Python, menu_type=hou.menuType.Normal)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.FloatParmTemplate("polylod", "Conversion Level of Detail", 1, default_value=([1]), min=0, max=5, min_is_strict=True, max_is_strict=False, look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.Base1)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("detectconstpointobjs", "Detect Constant Point Count Dynamic Objects", default_value=True, default_expression='on', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("convertsurfaces", "Convert NURBS and Bezier Surfaces to Polygons", default_value=False, default_expression='off', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("conservemem", "Conserve Memory at the Expense of Export Time", default_value=False, default_expression='off', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("deformsasvcs", "Export Deforms as Vertex Caches", default_value=False, default_expression='off', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("forceblendshape", "Force Blend Shape Export", default_value=False, default_expression='off', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("forceskindeform", "Force Skin Deform Export", default_value=False, default_expression='off', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ToggleParmTemplate("exportendeffectors", "Export End Effectors", default_value=True, default_expression='on', default_expression_language=hou.scriptLanguage.Hscript)
hou_parm_template.setTags({"autoscope": "0000000000000000"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
hou_parm_template = hou.ButtonParmTemplate("execute", "Save to Disk")
hou_parm_template.setTags({"autoscope": "0000000000000000", "takecontrol": "always"})
fbxNode.addSpareParmTuple(hou_parm_template, in_folder=(['Cache']), create_missing_folders=True)
children = fbxNode.children()
fbxNodeName = fbxNode.name().rsplit('_', 1)
charGeo = fbxNode.createNode('geo', fbxNodeName[0] + '_geo')
if len(charGeo.children()) > 0:
charGeo.children()[0].destroy() # older version of houdini had a lone file node
ccache = charGeo.createNode('alembic', 'char_abc_cache')
ccache.parm('fileName').set('`chs("../../cachefile")`')
cscale = charGeo.createNode('xform', 'cache_scale')
cscale.setFirstInput(ccache)
cscale.parm('scale').setExpression('ch("../../cache_scale")')
cswitch = charGeo.createNode('switch', 'cache_switch')
cswitch.parm('input').setExpression('ch("../../use_cache")')
exportNet = fbxNode.createNode('ropnet', 'exportnet')
alembicRop = exportNet.createNode('alembic', 'alembic')
alembicRop.parm('execute').setExpression('ch("../../cache_btn")')
alembicRop.parm('trange').setExpression('ch("../../trange")')
alembicRop.parm('f1').setExpression('ch("../../f1")')
alembicRop.parm('f2').setExpression('ch("../../f2")')
alembicRop.parm('f3').setExpression('ch("../../f3")')
alembicRop.parm('use_sop_path').set(1)
alembicRop.parm('sop_path').set('../../' + charGeo.name())
alembicRop.parm('build_from_path').set(1)
alembicRop.parm('path_attrib').set('path')
alembicRop.parm('root').set('')
fbxRop = exportNet.createNode('filmboxfbx', 'fbx')
fbxRop.parm('startnode').set('`opfullpath("../../")`')
fbxRop.parm('createsubnetroot').set(0)
fbxRop.parm('trange').setExpression('ch("../../trange2")')
fbxRop.parm('f1').setExpression('ch("../../f41")')
fbxRop.parm('f2').setExpression('ch("../../f42")')
fbxRop.parm('f3').setExpression('ch("../../f43")')
fbxRop.parm('take').setExpression('ch("../../take")')
fbxRop.parm('sopoutput').setExpression('ch("../../sopoutput")')
fbxRop.parm('mkpath').setExpression('ch("../../mkpath")')
fbxRop.parm('exportkind').setExpression('ch("../../exportkind")')
fbxRop.parm('sdkversion').setExpression('ch("../../sdkversion")')
fbxRop.parm('vcformat').setExpression('ch("../../vcformat")')
fbxRop.parm('invisobj').setExpression('ch("../../invisobj")')
fbxRop.parm('polylod').setExpression('ch("../../polylod")')
fbxRop.parm('detectconstpointobjs').setExpression('ch("../../detectconstpointobjs")')
fbxRop.parm('convertsurfaces').setExpression('ch("../../convertsurfaces")')
fbxRop.parm('conservemem').setExpression('ch("../../conservemem")')
fbxRop.parm('deformsasvcs').setExpression('ch("../../deformsasvcs")')
fbxRop.parm('forceblendshape').setExpression('ch("../../forceblendshape")')
fbxRop.parm('forceskindeform').setExpression('ch("../../forceskindeform")')
fbxRop.parm('exportendeffectors').setExpression('ch("../../exportendeffectors")')
fbxRop.parm('execute').setExpression('ch("../../execute")')
rigBox = fbxNode.createNetworkBox()
rigBox.setComment('Rig')
for child in children:
# for the fbxchop we need to rename it and set up a bclip/agent network to
# drive animation on the joints
if child.type().name() == 'chopnet':
child.destroy()
if child.type().name() == 'null':
# we want to set CHOP expressions for nulls so they move the bones with our mocap CHOPs
if child.name() is not fbxNodeName[0]: # check to make sure this is not the root null
child.parmTuple('t').deleteAllKeyframes()
child.parmTuple('r').deleteAllKeyframes()
child.parm('rx').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('ry').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('rz').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('tx').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('ty').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('tz').setExpression('chop("../CHOP/OUT/$OS:$CH")')
rigBox.addNode(child)
if child.type().name() == 'bone':
# add the bones to the rig net box
rigBox.addNode(child)
if child.type().name() == 'geo':
if child.name() is not charGeo.name():
# we want to convert these to a single geo pointing to a alembic
hou.copyNodesTo(child.children(), charGeo)
child.destroy()
rigBox.fitAroundContents()
# build the CHOP network
child = fbxNode.createNode('chopnet', 'CHOP')
#let's fetch the original tpose and place in in a bclip
fetch = child.createNode('fetch')
fetch.parm('rate').set(24)
fetch.parm('nodepath').set('../../* ')
bclip = fetch.clipData(True)
fileName = this.parm('char_bclip_file').eval()
f = open(hou.expandString(fileName), 'wb')
f.write(bclip)
f.close()
fetch.destroy()
tposeChop = child.createNode('file', 'tpose_clip')
tposeChop.parm('file').set(fileName)
agentChop = child.createNode('agent', 'mocap')
agentChop.parm('clipname').set('`chs("../../fbxclip")`')
switch = child.createNode('switch', 'switch')
switch.parm('index').setExpression('ch("../../mocapswitch")')
outChop = child.createNode('null', 'OUT')
sopNode = child.createNode('sopnet', 'fbxagent')
switch.setFirstInput(tposeChop)
switch.setNextInput(agentChop)
outChop.setFirstInput(switch)
fbxImport = sopNode.createNode('agent', 'fbximport')
fbxImport.parm('fbxfile').set('`chs("../../../fbxfile")`')
fbxImport.parm('input').set(2)
agentChop.parm('soppath').set('../fbxagent/fbximport')
outChop.setDisplayFlag(True)
#outChop.setRenderFlag(True)
child.layoutChildren()
# work on the character geo point all the captures to an alembic file
overMerge = charGeo.createNode('merge', 'merge')
alembic = charGeo.createNode('alembic', 'char_abc_geo')
fileName = this.parm('char_abc_file').eval()
alembic.parm('fileName').set(fileName)
unpack = charGeo.createNode('unpack', 'unpack')
unpack.setFirstInput(alembic)
unpack.parm('transfer_attributes').set('path shop_materialpath')
children = charGeo.children()
for child in children:
if child.type().name() == 'file':
nodeName = child.name()
deleteNode = charGeo.createNode('delete', 'isolate_' + nodeName)
deleteNode.parm('negate').set(1)
deleteNode.parm('group').set('@path="/' + nodeName + '/*"')
deleteNode.setFirstInput(unpack)
if len(child.outputs()) > 0:
delOutput = child.outputs()[0]
delOutput.setFirstInput(deleteNode)
child.destroy()
elif child.type().name() == 'deform':
child.destroy()
elif child.type().name() == 'channel':
child.destroy()
elif child.type().name() == 'capture':
child.setGenericFlag(hou.nodeFlag.Lock, False)
elif child.type().name() == 'captureoverride':
overMerge.setNextInput(child)
deform = charGeo.createNode('deform', 'deform')
deform.setFirstInput(overMerge)
cswitch.setFirstInput(deform)
cswitch.setNextInput(cscale)
cswitch.setDisplayFlag(True)
cswitch.setRenderFlag(True)
charGeo.layoutChildren()
hdaNode = fbxNode.createDigitalAsset(this.parm('asset_name').eval(), this.parm('hda_location').eval(), this.parm('desc').eval())
hdaDef = hdaNode.type().definition()
hdaOptions = hdaDef.options()
hdaDef.save(hdaDef.libraryFilePath(), hdaNode, hdaOptions)
def create_tmp_geoms(mantra):
"""
Create tmp geoms.
We use this method when we render objects which are
just part of the geometry (prim groups).
For HRST group we create a OBJ node for it.
"""
objects = mantra.objects
merge_dict = {}
for obj in objects:
if not obj.obj_path == obj.HRST_path:
tmp_subnet = hou.node(TMP_OBJ_SUBNET_PATH)
if not tmp_subnet:
tmp_subnet = hou.node('/obj/').createNode('subnet', TMP_OBJ_SUBNET_PATH.split('/')[-1])
tmp_subnet.hide(True)
tmp_subnet.setDisplayFlag(False)
#Create Object Node
objNode = tmp_subnet.node(obj.merge_SOP_name)
if not objNode:
# We have to copy all the object level settings to our new temp object
objNode = hou.copyNodesTo( [ hou.node(obj.HRST_path) ], hou.node(TMP_OBJ_SUBNET_PATH) )[0]
objNode.setName(obj.merge_SOP_name)
for c in objNode.children(): c.destroy()
#Create Object Merge SOP
object_merge_SOP = objNode.node(obj.merge_SOP_name)
if not object_merge_SOP:
object_merge_SOP = objNode.createNode('object_merge', obj.merge_SOP_name)
#Get the group name we want
prim_group = obj.prim_group.split('_primGroups_')[-1] if obj.prim_group.startswith('_primGroups_') else obj.prim_group
#Create a useful dictionary so we can put settings on the object_merge SOP easier.
if not merge_dict.has_key(obj.merge_SOP_name):
merge_dict[obj.merge_SOP_name] = {}
if not merge_dict[obj.merge_SOP_name].has_key(obj.HRST_path):
merge_dict[obj.merge_SOP_name][obj.HRST_path] = []
merge_dict[obj.merge_SOP_name][obj.HRST_path].append(prim_group)
#Set objects and groups
for obj_name in merge_dict:
for index, HRST_path in enumerate(merge_dict[obj_name]):
object_merge_SOP = hou.node("{0}/{1}/{2}".format(TMP_OBJ_SUBNET_PATH, obj_name, obj_name))
object_merge_SOP.parm('numobj').set(len(merge_dict[obj_name]))
object_merge_SOP.parm('xformtype').set(1)
object_merge_SOP.setRenderFlag(1)
object_merge_SOP.parm('objpath{0}'.format(index+1)).set(HRST_path)
for group in merge_dict[obj_name][HRST_path]:
group = '{0} {1} '.format(object_merge_SOP.parm('group{0}'.format(index+1)).eval(), group)
object_merge_SOP.parm('group{0}'.format(index+1)).set(group)
#Unselect all temp nodes
try:
for node in hou.selectedNodes():
node.setSelected(False)
except:
pass
def create_tmp_geoms(mantra):
"""
Create tmp geoms.
We use this method when we render objects which are
just part of the geometry (prim groups).
For HRST group we create a OBJ node for it.
"""
objects = mantra.objects
merge_dict = {}
for obj in objects:
if not obj.obj_path == obj.HRST_path:
tmp_subnet = hou.node(TMP_OBJ_SUBNET_PATH)
if not tmp_subnet:
tmp_subnet = hou.node('/obj/').createNode(
'subnet',
TMP_OBJ_SUBNET_PATH.split('/')[-1])
tmp_subnet.hide(True)
tmp_subnet.setDisplayFlag(False)
#Create Object Node
objNode = tmp_subnet.node(obj.merge_SOP_name)
if not objNode:
# We have to copy all the object level settings to our new temp object
objNode = hou.copyNodesTo([hou.node(obj.HRST_path)],
hou.node(TMP_OBJ_SUBNET_PATH))[0]
objNode.setName(obj.merge_SOP_name)
for c in objNode.children():
c.destroy()
#Create Object Merge SOP
object_merge_SOP = objNode.node(obj.merge_SOP_name)
if not object_merge_SOP:
object_merge_SOP = objNode.createNode('object_merge',
obj.merge_SOP_name)
#Get the group name we want
prim_group = obj.prim_group.split(
'_primGroups_')[-1] if obj.prim_group.startswith(
'_primGroups_') else obj.prim_group
#Create a useful dictionary so we can put settings on the object_merge SOP easier.
if not merge_dict.has_key(obj.merge_SOP_name):
merge_dict[obj.merge_SOP_name] = {}
if not merge_dict[obj.merge_SOP_name].has_key(obj.HRST_path):
merge_dict[obj.merge_SOP_name][obj.HRST_path] = []
merge_dict[obj.merge_SOP_name][obj.HRST_path].append(prim_group)
#Set objects and groups
for obj_name in merge_dict:
for index, HRST_path in enumerate(merge_dict[obj_name]):
object_merge_SOP = hou.node("{0}/{1}/{2}".format(
TMP_OBJ_SUBNET_PATH, obj_name, obj_name))
object_merge_SOP.parm('numobj').set(len(merge_dict[obj_name]))
object_merge_SOP.parm('xformtype').set(1)
object_merge_SOP.setRenderFlag(1)
object_merge_SOP.parm('objpath{0}'.format(index +
1)).set(HRST_path)
for group in merge_dict[obj_name][HRST_path]:
group = '{0} {1} '.format(
object_merge_SOP.parm('group{0}'.format(index + 1)).eval(),
group)
object_merge_SOP.parm('group{0}'.format(index + 1)).set(group)
#Unselect all temp nodes
try:
for node in hou.selectedNodes():
node.setSelected(False)
except:
pass
def convertV1_to_V2(nodes):
for node in nodes:
if node.type().name() == "byu_geo":
node = node.parent().createNode(node.parm("asset_name").evalAsString() + "_main")
geometry = next((child for child in node.children() if child.type().name() == "geo"), None)
shopnet = next((child for child in node.children() if child.type().name() == "shopnet"), None)
print geometry
# If there's not a geometry network inside that has the same name as the operator,
# then it's probably not an old BYU asset that we know how to deal with, so skip it.
if not geometry or not shopnet or geometry.name() not in node.type().name() or geometry.name() not in shopnet.name():
continue
root = geometry.node("hide_geo")
print root
if not root:
continue
checkout.checkout_asset_go(node)
parent = node.parent()
output = geometry.displayNode()
# Find descendants of the root node, these are the old components
descendants = []
stack = []
stack.append(root)
while len(stack) > 0:
ancestor = stack.pop()
descendants.append(ancestor)
for output in ancestor.outputs():
stack.append(output)
# Tab in a V2 Dynamic Content Subnet
asset_name = geometry.name()
new_node=None
new_node = tab_in(parent, asset_name, excluded_departments=[Department.MODIFY, Department.MATERIAL])
# Copy old components into a modify node
modify_node = create_hda(asset_name, Department.MODIFY, already_tabbed_in_node=new_node)
display_out=modify_node.displayNode()
copied_nodes=hou.copyNodesTo(descendants, modify_node)
## TODO: PARSE THROUGH NODES AND CONNECT TO OUTPUT
hide_geo=None
descend_out=None
mat_node=None
for copied_node in copied_nodes:
if 'switch' in copied_node.type().name():
hide_geo=copied_node
elif 'material' == copied_node.type().name():
mat_node=copied_node
elif 'output' == copied_node.type().name():
descend_out=copied_node
elif 'null' == copied_node.type().name() and 'OUT' in copied_node.name():
descend_out=copied_node
hide_geo.setInput(0,modify_node.indirectInputs()[0])
display_out.setInput(0,descend_out)
display_out.setDisplayFlag(True)
display_out.setRenderFlag(True)
display_out.setInput(0,descend_out)
modify_node.layoutChildren()
descend_out.destroy()
hide_geo.destroy()
mat_node.destroy()
# Copy old components into a material node
material_node = create_hda(asset_name, Department.MATERIAL, already_tabbed_in_node=new_node)
hou.copyNodesTo(shopnet.children(), material_node.node("shopnet/shaders"))
# Do material assignment as much as possible
# TODO: riley
material= geometry.node("material1")
num_groups=material.evalParm('num_materials')
#map of material to string of group mask
info={}
for i in range(1,num_groups+1):
group=material.evalParm('group'+str(i))
mat=material.evalParm('shop_materialpath'+str(i))
mat='../shopnet/shaders/'+'/'.join(mat.split('/')[-2:])
if mat in info:
info[mat]+=' '+group
else:
info[mat]=group
mat_assign=material_node.node('material_assign')
mat_assign.parm('num_materials').set(len(info))
#transfer material assignments
for i,key in enumerate(info):
mat_assign.parm('group'+str(i+1)).set(info[key])
mat_assign.parm('material_options'+str(i+1)).set(1)
mat_assign.parm('mat_option'+str(i+1)+'_1').set(key)
# Name the nodes
node.setName(asset_name + "_old")
new_node.setName(asset_name + "_new")
# Put them both into a network box, so we can see that they are related.
box = parent.createNetworkBox()
box.addItem(node)
box.addItem(new_node)
box.fitAroundContents()
box.setComment(node.type().name().replace("_main", "").title())
parent.layoutChildren()
import platform
import subprocess
from subprocess import Popen
num_split = 2
myFile = hou.hipFile.path()
os.chdir(hou.getenv('HIP'))
orgNodes = hou.selectedNodes()
rops = []
if (len(orgNodes)==1):
orgNode = orgNodes[0]
startFrame = orgNode.parm('f1').eval()
#print(startFrame)
for i in range(num_split):
hou.copyNodesTo(orgNodes,hou.node('/out/'))
copiedNode = hou.selectedNodes()[0]
copiedNode.parm('f1').deleteAllKeyframes()
copiedNode.parm('f3').deleteAllKeyframes()
copiedNode.parm('f1').set(startFrame+i)
copiedNode.parm('f3').set(num_split)
copiedNode.moveToGoodPosition()
rops.append(copiedNode)
#print(rops)
print('saved hip file')
hou.hipFile.save()
for rop in rops:
ropPath = rop.path()
def selectSubnet(self):
FBX = hou.selectedNodes()[0]
#Root Location
OBJ = hou.node('/obj/')
if not FBX:
#Error no fbx sub detected.
print("Error: No objects selected.")
elif FBX:
if FBX.type().name() == "subnet":
# Create Geometry node to store FBX parts
geometry = OBJ.createNode('geo', run_init_scripts=False)
geometry.setName('GEO_{}'.format(FBX.name()))
geometry.moveToGoodPosition()
# Get all parts inside FBX container
geometry_FBX = [
node for node in FBX.children()
if node.type().name() == 'geo'
]
# Create merge node for parts
merge = geometry.createNode('merge')
merge.setName('master_merge')
#Create Null Object at the end
oNull = geometry.createNode('null')
oNull.setName('OUT_DAZ')
#Link MergeOut to NullIn
oNull.setInput(0, merge)
# Replicate FBX structure in Geometry node
for geo in geometry_FBX:
# Create Object Merge node
objectMerge = geometry.createNode('object_merge')
objectMerge.setName(geo.name())
# Set path to FBX part object
objectMerge.parm('objpath1').set(geo.path())
objectMerge.parm('xformtype').set(1)
# MATERIAL HANDLING
# Copy Material from Geo
matName = hou.node("obj/" + FBX.name() + "/" + geo.name() +
"/" + geo.name() + "_material")
if matName is not None:
parentH = hou.node("obj/" + geometry.name())
hou.copyNodesTo([matName], parentH)
material = hou.node("obj/" + geometry.name() + "/" +
geo.name() + "_material")
#Call process to convert materials.
if self.mw.rdo_Arnold.isChecked() == True:
print("Converting to Arnold Materials.")
self.convertArnold(material)
else:
# Create Material node if none exist. No materials are added if none are detected.
material = geometry.createNode('material')
material.setName('MAT_{}'.format(geo.name()))
# LINK NODES
# Link Material to Object MergeName
material.setNextInput(objectMerge)
# Link part to Merge
merge.setNextInput(material)
# Set Null Node flags to Render
oNull.setDisplayFlag(1)
oNull.setRenderFlag(1)
# Layout geometry content in Network View
geometry.layoutChildren()
else:
print(
"NON-SUBNET Node Selected. Hint:You may only select one node at a time."
)
def __init__(self, node, rig_subnet):
print "muscle"
self.node = node
self.rig_subnet = rig_subnet
self.limb_subnet = self.create_rig_node(self.rig_subnet)
self.node_rename(self.node, self.limb_subnet)
self.make_color(self.node)
self.colorize_node(self.limb_subnet, self.color)
self.position_node(self.node, self.limb_subnet)
#todo put all this into smaller functions
copy_self_node = hou.copyNodesTo([self.node], self.node.parent())
copy_self_node = copy_self_node[0]
copy_self_node.node("fetch_parent").destroy()
copy_self_node.node("fetch_parent1").destroy()
hou.copyNodesTo(copy_self_node.children(), self.limb_subnet)
copy_self_node.destroy()
# creating the nodes into variables--------------------------------------------------------------
fetch = self.create_fetch_import(self.node.parm("hook"),
self.limb_subnet)
fetch_upper = self.create_fetch_import(self.node.parm("hook_upper"),
self.limb_subnet)
list_of_fetchers = [fetch, fetch_upper]
self.o_position = self.limb_subnet.node("origin_position")
self.i_position = self.limb_subnet.node("insertion_position")
self.center_offset = self.limb_subnet.node("center_offset")
self.muscle_node = self.limb_subnet.node("muscle")
self.chop_muscle = self.limb_subnet.node("chopnet_muscle")
self.jiggle_switch_node = self.chop_muscle.node("switch_jiggle_effect")
self.jiggle_node = self.chop_muscle.node("jiggle_center_muscle")
list_of_positioners = [self.o_position, self.i_position]
for index, i in enumerate(list_of_positioners):
# i.parm("keeppos").set(0)
i.setInput(0, list_of_fetchers[index])
# i.parm("keeppos").set(1)
self.limb_subnet.layoutChildren()
muscle_node = self.limb_subnet.node("muscle")
muscle_node.parm("tdisplay").set(1)
try:
muscle_node_position = muscle_node.position()
chop_node = self.limb_subnet.node("chopnet_muscle")
chop_node.setPosition(
[muscle_node_position[0], (muscle_node_position[1] - .5)])
except:
pass
self.muscle_view()
self.promote_parms(self.rig_subnet, ["Rig Parms", self.node.name()])
self.promote_viz_positioners()
gv.muscle_deformers_list.append(muscle_node)
def go(self, node=None):
self.hda = node
environment = Environment()
project = Project()
hda_dir = environment.get_hda_dir()
if self.hda is None:
self.hda = get_selected_node()
if self.hda is None:
return
node_path = self.hda.path()
name = node_path.split('/')[-1]
tool_name = name.lower()
if tool_name is None:
return
if not self.hda.canCreateDigitalAsset():
if self.hda.type().definition is not None:
# we are dealing with an premade self.hda
result = qd.yes_or_no(
'The selected node is already a digial asset. Would you like to copy the definition into the pipeline'
)
if not result:
return
else:
copyHDA = True
else:
qd.error(
'You can\'t make a digital asset from the selected node')
return
else:
copyHDA = False
destination = os.path.join(hda_dir, tool_name + ".hda")
operatorName = tool_name
operatorLabel = str(project.get_name()) + '_' + str(tool_name)
saveToLibrary = destination
num_inputs = len(self.hda.inputs())
if copyHDA:
parent = self.hda.parent()
subnet = parent.createNode('subnet')
hda_node = subnet.createDigitalAsset(name=operatorName,
description=operatorLabel,
hda_file_name=saveToLibrary,
min_num_inputs=num_inputs)
hou.copyNodesTo(self.hda.children(), hda_node)
hda_nodeDef = hda_node.type().definition()
hdaDef = self.hda.type().definition()
#Copy over sections
sects = hdaDef.sections()
for sectName in sects:
hda_nodeDef.addSection(sectName, sects[sectName].contents())
#Copy over NodeGroups
nodeGroups = self.hda.nodeGroups()
for ng in nodeGroups:
newNg = hda_node.addNodeGroup(ng.name())
for node in ng.nodes():
nodePath = hda_node.path() + '/' + str(node.name())
newNode = hou.node(nodePath)
if newNode is None:
print('Ya that node was null that is a problem')
continue
newNg.addNode(newNode)
# Copy over paramters
oldParms = hdaDef.parmTemplateGroup()
hda_nodeDef.setParmTemplateGroup(oldParms)
else:
try:
hda_node = self.hda.createDigitalAsset(
name=operatorName,
description=operatorLabel,
hda_file_name=saveToLibrary,
min_num_inputs=num_inputs)
except hou.OperationFailed, e:
qd.error('There was a problem creating a digital asset',
details=str(e))
return
def ConvertJointsToBones(fbxNode):
#print 'begin convert fbxNode', fbxNode.name()
newNodes = []
parentNullNodes = []
destroyList = []
geoList = []
for child in fbxNode.children():
childTypeName = child.type().name()
if childTypeName == 'bone':
childInputs = child.inputs()
if childInputs is not None and len(childInputs) > 0:
jointParentNode = child.inputs()[0]
parentNullNodes.append(jointParentNode)
jointParentNode.parm('keeppos').set(True)
#jointParentName = jointParentNode.name()
#jointRealName = jointParentName.split('_')[-1]
#print child.name(), '->' , child.inputs()
realBoneNode = fbxNode.createNode('bone')#,'bone_'+jointRealName)
realBoneNode.parm('length').set(child.parm('length').eval())
realBoneNode.setColor(hou.Color(1,0,0))
#realBoneNode.setInput(0,None,0)
newNodes.append(realBoneNode)
BasicFunc.connect_node(child, realBoneNode)
BasicFunc.alignWorldPos(realBoneNode, jointParentNode)
realBoneNode.parm('keeppos').set(True)
BasicFunc.adjustLayout(realBoneNode)
child.setDisplayFlag(False)
destroyList.append(child)
elif childTypeName == 'geo':
geoList.append(child)
elif childTypeName == 'null':
if len(child.outputs()) == 0:
childInputs = child.inputs()
if childInputs is not None and len(childInputs)>0:
if JointsToBones.IsNodeJoint(childInputs[0]):
# this is the end joint
child.parm('keeppos').set(True)
endBone = fbxNode.createNode('bone')
endBone.parm('length').set(0)
BasicFunc.connect_node(child, endBone)
endBone.parm('keeppos').set(True)
BasicFunc.adjustLayout(endBone)
newNodes.append(endBone)
parentNullNodes.append(child)
#BasicFunc.layoutChildren(fbxNode, newNodes, 0, 1)
for i in range(len(newNodes)):
mother = parentNullNodes[i]
motherInputs = mother.inputs()
if motherInputs is not None and len(motherInputs)>0:
grandma = motherInputs[0]
if grandma in parentNullNodes:
father = newNodes[parentNullNodes.index(grandma)]
BasicFunc.connect_node(father, newNodes[i])
else:
newNodes[i].setInput(0,None,0)
targetNames = []
for i in range(len(newNodes)):
try:
targetName = parentNullNodes[i].name()
#parentNullNodes[i].destroy()
if not parentNullNodes[i] in destroyList:
destroyList.append(parentNullNodes[i])
targetNames.append(targetName)
# newNodes[i].setName(targetName)
except:
print 'exception on:', newNodes[i]
for dn in destroyList:
dn.destroy()
for i in range(len(newNodes)):
newNodes[i].setName(targetNames[i],True)
for geoNode in geoList:
# find bone capture node
currentRenderNode = geoNode.renderNode()
captureNode = None
for insideNode in geoNode.children():
# print insideNode
if insideNode.type().name() == 'capture':
captureNode = insideNode
break
if captureNode:
print 'capture node:', captureNode
cpNode = hou.copyNodesTo((captureNode,), geoNode)[0]
cpNode.setHardLocked(False)
attrCopyNode = geoNode.createNode('attribcopy')
BasicFunc.connect_node(cpNode, attrCopyNode,0,0)
BasicFunc.connect_node(captureNode, attrCopyNode,0,1)
attrCopyNode.parm('attribname').set('*')
BasicFunc.connect_node(attrCopyNode, currentRenderNode)
def make_compatible_fbx_hierarchy(character_subnet):
character_subnet_children = character_subnet.children()
nulls = utl.nodetypes_in_list(character_subnet_children, "null")
geos = utl.nodetypes_in_list(character_subnet_children, "geo")
target_nulls = []
bones = []
bone_name_map = {}
old_to_new_map = {}
# lock the current mesh deformation
for geo in geos:
geo.displayNode().setHardLocked(True)
utl.nodetype_in_list(geo.children(),
"captureoverride").setHardLocked(True)
# move cregion sops into bones, break the rig (temporarily)
# writes bone-null correspondance for further bone weight transfer
for null in nulls:
cregion = utl.nodetype_in_list(null.children(), "cregion")
if cregion:
children = []
for child in null.outputConnections():
children.append(child.outputNode())
children = utl.nodetypes_in_list(children, "bone")
if len(children) > 1:
# this is for gathering nulls which have multple bone children
# later on those bones will get a separate parent null
# to move the pretransform from the bone
target_nulls.append(null)
bones.extend(children)
for child_bone in children:
capt = hou.copyNodesTo([cregion], child_bone)[0]
child_bone.displayNode().setInput(2, capt)
bone_name_map[child_bone.name()] = null.name()
old_to_new_map[null.name()] = children
cregion.destroy()
# for each bone with non-unique parent add control null
for bone in bones:
ctrl_null = bone.parent().createNode("null", bone.name() + "_ctrl")
ctrl_null.setPosition(bone.position())
ctrl_null.move([0, 1])
ctrl_null.setNextInput(bone)
ctrl_null.parm("keeppos").set(True)
ctrl_null.setInput(0, None)
bone.setPreTransform(hou.Matrix4(1))
ctrl_null.setNextInput(bone.inputConnections()[0].inputNode())
bone.setInput(0, ctrl_null)
ctrl_null.parm("keeppos").set(False)
ctrl_null.setDisplayFlag(False)
# remove pre-transform from bones and move them to the parent nulls
bones = utl.nodetypes_in_list(character_subnet_children, "bone")
for bone in bones:
world_transform = bone.worldTransform()
bone.setPreTransform(hou.Matrix4(1))
bone.inputConnections()[0].inputNode().setWorldTransform(
world_transform)
def ordered_bone_names_list(unpacked_attribs_node):
# get capture paths
attrib_vals = unpacked_attribs_node.geometry().stringListAttribValue(
"boneCapture_pCaptPath")
bone_names = []
for value in attrib_vals:
name_parts = value.split("/")
bone_name = ""
for x in range(len(name_parts) - 1):
bone_name += name_parts[x] + "/"
bone_names.append(bone_name[:-1])
return bone_names
# re-capture with the new bones
for geo in geos:
capture_source_frozen = utl.nodetype_in_list(geo.children(), "capture")
bc_names = capture_source_frozen.parm("extraregions").eval().split(" ")
for x in range(len(bc_names)):
bc_names[x] = bc_names[x].replace("../../", "")
bc_names[x] = bc_names[x].replace("/cregion", "")
capture_source = utl.nodetype_in_list(geo.children(),
"captureoverride")
unpacked_source = geo.createNode("captureattribunpack",
"unpacked_source")
unpacked_source.setNextInput(capture_source)
source_bone_names_ordered = ordered_bone_names_list(unpacked_source)
bones_parm_list = []
for source_bone_name in source_bone_names_ordered:
#if source_bone_name:
bones_parm_list.extend(old_to_new_map[source_bone_name])
capture = utl.append_sop_node(geo, "capture")
parm_val = ""
for bone in bones_parm_list:
parm_val += "../../" + bone.name() + "/cregion "
capture.parm("extraregions").set(parm_val)
capture.setParms({"extraregions": parm_val})
unpacked_dst = utl.append_sop_node(geo, "captureattribunpack",
"unpacked_source")
dst_bone_names_ordered = ordered_bone_names_list(unpacked_dst)
snippet = ""
for idx, point in enumerate(unpacked_dst.geometry().points()):
indices = []
data = []
unpacked_source_point = unpacked_source.geometry().iterPoints(
)[idx]
source_indices = unpacked_source_point.intListAttribValue(
"boneCapture_index")
source_data = unpacked_source_point.floatListAttribValue(
"boneCapture_data")
for x in range(len(source_data)):
weight = source_data[x]
target_bone = source_bone_names_ordered[source_indices[x]]
new_bones = old_to_new_map[target_bone]
for new_bone in new_bones:
new_bone_name = new_bone.name()
new_bone_list_id = dst_bone_names_ordered.index(
new_bone_name)
indices.append(new_bone_list_id)
data.append(weight)
data_str = ""
idx_str = ""
for idx, d in enumerate(data):
data_str += str(d) + ","
idx_str += str(indices[idx]) + ","
data_str = "array(" + data_str[:-1] + ")"
idx_str = "array(" + idx_str[:-1] + ")"
snippet += 'setpointattrib(geoself(), "boneCapture_data", ' + str(
point.number()) + ", float[](" + data_str + "));"
snippet += 'setpointattrib(geoself(), "boneCapture_index", ' + str(
point.number()) + ", int[](" + idx_str + "));"
attribwrangle = utl.append_sop_node(geo, "attribwrangle")
attribwrangle.setNextInput(unpacked_dst)
attribwrangle.setParms({"class": 0, "snippet": snippet})
utl.append_sop_node(geo, "captureattribpack")
utl.append_sop_node(geo, "deform")
unpacked_source.destroy()
def convertSubnet(node, ignoreUnlock=0, Only_FeEHDA=1, ignore_SideFX_HDA=1):
nodeType = node.type()
if nodeType.name() == 'subnet':
convertSubnet_recurseSubChild(node, node, '', ignoreUnlock,
Only_FeEHDA, ignore_SideFX_HDA)
definition = nodeType.definition()
if definition is None:
return
if ignoreUnlock and not node.matchesCurrentDefinition():
#print(node)
convertSubnet_recurseSubChild(node, node, '', ignoreUnlock,
Only_FeEHDA)
return
if ignore_SideFX_HDA:
defaultLibPath = hou.getenv('HFS') + r'/houdini/otls/'
if definition.libraryFilePath().startswith(defaultLibPath):
convertSubnet_recurseSubChild(node, node, '', ignoreUnlock,
Only_FeEHDA)
return
node.allowEditingOfContents()
parent = node.parent()
#print(parent.childTypeCategory().name())
if parent.childTypeCategory().name() != 'Sop':
raise ('error')
if node.isHardLocked():
raise ('isHardLocked')
if node.isSoftLocked():
raise ('isSoftLocked')
displayFlag = node == parent.displayNode()
renderFlag = node == parent.renderNode()
bypass = node.isBypassed()
isTemplateFlagSet = node.isTemplateFlagSet()
isHighlightFlagSet = node.isHighlightFlagSet()
isSelectableTemplateFlagSet = node.isSelectableTemplateFlagSet()
isUnloadFlagSet = node.isUnloadFlagSet()
inputConnectors = node.inputConnectors()
nInputs = len(inputConnectors)
if nInputs > 4:
shiftVector2 = hou.Vector2(0.0, -1.0)
nulls = []
for idx in range(4, nInputs): #算出nulls列表的所有元素，后面有用
if len(inputConnectors[idx]) == 0:
nulls.append(None) #没有连
continue
inputConnection = inputConnectors[idx][0]
#inputItem = inputConnection.inputItem()
subnetIndirectInput = inputConnection.subnetIndirectInput()
if subnetIndirectInput is None:
nulls.append(inputConnection.inputNode())
else:
null = None
for outputConnection in subnetIndirectInput.outputConnections(
):
outputNode = outputConnection.outputNode()
if outputNode.type().name() == 'null':
if outputNode.parm('copyinput').evalAsInt() == 1:
null = outputNode
nulls.append(null)
break
if null is None:
if 1:
null = subnetIndirectInput.createOutputNode(
'null', exact_type_name=True)
else:
null = parent.createNode('null', exact_type_name=True)
null.setInput(0, subnetIndirectInput, output_index=0)
# null.setPosition(subnetIndirectInput.position().__add__(shiftVector2))
null.setPosition(subnetIndirectInput.position() +
shiftVector2)
nulls.append(null)
indirectInputs = node.indirectInputs()
for idx in range(4, nInputs):
if nulls[idx - 4] is None: #没有连
continue
objectMerge = node.createNode('object_merge', exact_type_name=True)
objectMerge.parm('objpath1').set('../../' + nulls[idx - 4].name())
objectMerge.setPosition(indirectInputs[idx].position())
for outputConnection in indirectInputs[idx].outputConnections():
outputNode = outputConnection.outputNode()
outputNode.setInput(outputConnection.inputIndex(), objectMerge)
#origNodeshape = node.userData('nodeshape')
copyOrigNode = hou.copyNodesTo([node], parent)[0]
newNode = node.changeNodeType('subnet', keep_parms=False)
newNode.removeSpareParms()
# newNode.parm('label1').hide(True)
# newNode.parm('label2').hide(True)
# newNode.parm('label3').hide(True)
# newNode.parm('label4').hide(True)
copyParms_NodetoNode(copyOrigNode, newNode)
#if origNodeshape is not None:
#这个是自动的啦
#pass
#newNode.setUserData('nodeshape', origNodeshape)
newNodeParmTemplateGroup = newNode.parmTemplateGroup()
# folder = newNodeParmTemplateGroup.findFolder('Standard')
# folder.endsTabGroup()
#print(folder)
#newNodeParmTemplateGroup.hideFolder('Standard', True)
#newNode.setParmTemplateGroup(newNodeParmTemplateGroup, rename_conflicting_parms=False)
#newNode.removeSpareParmFolder(('Standard', ))
#newNode.removeSpareParmTuple(newNode.parmTuple('Standard'))
newNode.setDisplayFlag(displayFlag)
newNode.setRenderFlag(renderFlag)
newNode.bypass(bypass)
newNode.setTemplateFlag(isTemplateFlagSet)
newNode.setHighlightFlag(isHighlightFlagSet)
newNode.setSelectableTemplateFlag(isSelectableTemplateFlagSet)
newNode.setUnloadFlag(isUnloadFlagSet)
copyOrigNode.destroy()
convertSubnet_recurseSubChild(newNode, newNode, '', ignoreUnlock,
Only_FeEHDA, ignore_SideFX_HDA)
def bakeObjectToWorld(startFrame, endFrame):
selectedNode=hou.selectedNodes()
selectedNodeName=selectedNode[0].name()
parent=selectedNode[0].parent()
bakeNode=hou.copyNodesTo(selectedNode,parent)
bakeNode[0].setName(selectedNodeName + "_bake")
bakeNode[0].parm("keeppos").set(0)
fetchNode=hou.node(parent.path()).createNode("fetch","fetch_"+selectedNodeName)
hou.node(fetchNode.path()).parm("fetchobjpath").set(selectedNode[0].path())
hou.node(fetchNode.path()).parm("useinputoffetched").set(1)
nullNode=hou.node(parent.path()).createNode("null")
nullNode.setFirstInput(fetchNode)
nullNodeName=nullNode.name()
parms=["tx","ty","tz","rx","ry","rz"]
constant=["TX","TY","TZ","RX","RY","RZ"]
bakeNode[0].setInput(0,None)
#delete expresssion in parms and set to 0
for p in parms:
bakeNode[0].parm(p).deleteAllKeyframes()
hou.hscript('objextractpretransform '+ bakeNode[0].path())
bakeNode[0].parm(p).set(0)
for p, c in zip(parms, constant):
#bakeNode[0].parm(p).deleteAllKeyframes()
hou.node(bakeNode[0].path()).parm(p).setExpression('origin("","../'+nullNodeName+'",'+c+')')
#add dict for hou.Keyframe and values
key = dict([(x, hou.Keyframe()) for x in parms])
values = dict([(x, []) for x in constant])
#bake time range
timeRange = xrange(startFrame,endFrame+1)
#fill values dict
for t in timeRange:
hou.setFrame(t)
for v, p in zip(constant,parms):
values[v].append(bakeNode[0].parm(p).eval())
for p in parms:
bakeNode[0].parm(p).deleteAllKeyframes()
bakeNode[0].parm(p).set(0)
#set key by keyframes
for t in timeRange:
hou.setFrame(t)
for v, p, k in zip(constant,parms,key):
key[k].setValue(values[v][t-startFrame])
bakeNode[0].parm(p).setKeyframe(key[k])
fetchNode.destroy()
nullNode.destroy()
# 09
materiallibrary2 = materiallibrary.copyTo(stage)
materiallibrary2.parm("geopath1").set("/soccerball_sim/piece*")
materiallibrary2.setInput(0,rendergeometrysettings)
# 10
domelight = hou.node("/stage/camera2")
domelight.setSelected(True,True)
node = domelight.outputs()
while(len(node) > 0):
node = node[0]
node.setSelected(True)
node = node.outputs()
copyNodes = hou.copyNodesTo(hou.selectedNodes(), stage)
# 11
camera = copyNodes[0]
camera.setInput(0,materiallibrary2)
karma = copyNodes[-1]
karma.parm("camera").set(camera.parm("primpath").eval())
karma.parm("picture").set("$HIP/render/soccerbal_sim_$F.exr")
karma.setDisplayFlag(True)
karma.parm("execute").pressButton()
# 全ノードをいい位置に移動
for node in hou.node("/").allSubChildren():
node.moveToGoodPosition()
def results(self, value):
self.asset_name = value[0]
body = Project().get_asset(self.asset_name)
if not body:
body = self.project.create_asset(self.asset_name)
if not body:
qd.error("Something broke :'(")
return
self.element = body.get_element(Asset.MATERIALS)
self.path = os.path.join(self.element._filepath, "temp.usda")
selection = hou.selectedNodes()
if len(selection) != 1:
qd.error("Please select only the material node and try again.")
return
shader = selection[0]
if shader.type().name == "materiallibrary":
qd.error(
"Changes have been made to this publishing tool. Now you must select the material node itself, NOT the material library, to publish it. Please try again."
)
return
#check where we are and move shader node accordingly
deleteLib = False
path = shader.path()
first = path.split("/")[1]
if first != "stage":
lib = hou.node("/stage").createNode("materiallibrary")
deleteLib = True
shader = hou.copyNodesTo([shader], lib)[0]
else:
lib = shader.parent()
lib.setInput(0, None)
lib.parm("matpath1").set(value[0])
#create and save material hda
if shader.canCreateDigitalAsset():
hdaPath = os.path.join(self.element._filepath,
self.asset_name + "_main.hda")
shader = shader.createDigitalAsset(name=re.sub(
r'\W+', '', self.asset_name),
description=self.asset_name,
hda_file_name=hdaPath,
min_num_inputs=0,
max_num_inputs=0)
shaderDef = shader.type().definition()
shaderOptions = shaderDef.options()
shaderOptions.setUnlockNewInstances(True)
shaderOptions.setSaveInitialParmsAndContents(True)
shaderDef.setOptions(shaderOptions)
shaderDef.save(hdaPath, shader, shaderOptions)
elif shader.type().name() == re.sub(r'\W+', '', self.asset_name):
shader.type().definition().updateFromNode(shader)
shader.type().definition().save(
shader.type().definition().libraryFilePath())
else:
qd.error("Error creating/saving hda. Continuing to save USDA...")
shader.setName(value[0])
rop = hou.node("/stage").createNode("usd_rop")
rop.setInput(0, lib)
rop.parm("lopoutput").set(self.path)
rop.parm("enableoutputprocessor_simplerelativepaths").set(0)
rop.parm("execute").pressButton()
rop.destroy()
if deleteLib:
lib.destroy()
publishes = self.element.list_publishes()
publishes_string_list = ""
for publish in publishes:
label = publish[0] + " " + publish[1] + " " + publish[2] + "\n"
publishes_string_list += label
self.input = qd.HoudiniInput(parent=hou.qt.mainWindow(),
title="Comment ",
info=publishes_string_list)
self.input.submitted.connect(self.comment_results)
import hou, os
sel = hou.selectedNodes()
if sel:
for s in sel:
out = s.parent().createNode('geo', run_init_scripts=0)
out.moveToGoodPosition()
new_shop = out.createNode('shopnet', 'SHADERS')
geo = [x for x in s.children() if x.type().name() == 'geo']
old_shop = hou.node(s.path() + '/materials')
hou.copyNodesTo(old_shop.children(), new_shop)
m = out.createNode('merge')
delete = []
delete.append(m)
material_dict = {}
for g in geo:
material = g.parm('shop_materialpath').eval()
if material != '':
material = material.split('/')[-1]
material_dict[g.name()] = material
else:
mat_nodes = [
x for x in g.children() if x.type().name() == 'material'
]
for i in mat_nodes:
num_materials = i.parm('num_materials').eval()
num = 0
while num < num_materials:
num += 1
def idConvertROP(node):
new = hou.copyNodesTo((node, ), hou.node("/out"))[0]
oldName = node.name()
oldPos = node.position()
#new.moveToGoodPosition()
oldPos += hou.Vector2((1, 1))
new.setPosition(oldPos)
new.setName(oldName + "_id", unique_name=True)
new.setColor(hou.Color((0, .2, .8)))
# disable params
planes = new.parm("vm_numaux")
planes.revertToDefaults()
planes = new.parmsInFolder(("Images", "Extra Image Planes"))
for plane in planes:
if "quick" in plane.name():
plane.revertToDefaults()
idParms = {
"vm_exportcomponents": "",
"sololight": "",
"alights": "",
"forcelights": "",
"excludelights": "",
"vm_reflectlimit": "",
"vm_reflectlimit": 0,
"vm_refractlimit": 0,
"vm_diffuselimit": 0,
"vm_volumelimit": 0,
"vm_maxraysamples": 1,
"vm_subpixel": 1
}
new.setParms(idParms)
# add Prim_Id and Obj_Id planes
planes = new.parm("vm_numaux")
planes.insertMultiParmInstance(0)
planes.insertMultiParmInstance(0)
idPlanes = {
"vm_variable_plane1": "Op_Id",
"vm_vextype_plane1": "float",
"vm_quantize_plane1": "float",
"vm_variable_plane2": "Prim_Id",
"vm_vextype_plane2": "float",
"vm_quantize_plane2": "float"
}
new.setParms(idPlanes)
# add deep params, enable deep output
cmd = "opproperty -f " + new.path() + " mantra* *dcm*"
#hou.hscript(cmd)
deepSettings = {
"vm_deepresolver": "camera",
"vm_dcmpzstorage": "real16",
"vm_dcmzbias": 0.00025,
"vm_dcmofsize": "1"
}
#new.setParms(deepSettings)
# set image and deep paths
#deepFile = new.parm("vm_dcmfilename")
flatFile = new.parm("vm_picture")
ifdFile = new.parm("soho_diskfile")
oldPath = node.path()
#deepFile.setExpression("hou.session.hpipe.idPath(hou.node(\"" + oldPath + "\"), \"deep\")", language=hou.exprLanguage.Python)
flatFile.setExpression("hou.session.hpipe.idPath(hou.node(\"" + oldPath +
"\"), \"id\")",
language=hou.exprLanguage.Python)
ifdFile.setExpression("hou.session.hpipe.idPath(hou.node(\"" + oldPath +
"\"), \"id\", src=\"ifd\" )",
language=hou.exprLanguage.Python)
def create_hda(self, value):
tool_name = create_window.result
if tool_name is None:
return
if not self.hda.canCreateDigitalAsset():
if self.hda.type().definition is not None:
# we are dealing with an premade self.hda
result = qd.yes_or_no(
'The selected node is already a digial asset. Would you like to copy the definition into the pipeline'
)
if not result:
return
copyHDA = True
else:
qd.error(
'You can\'t make a digital asset from the selected node')
return
else:
copyHDA = False
project = Project()
environment = Environment()
username = project.get_current_username()
tool = project.get_tool(tool_name)
hda_element = tool.get_element(Department.HDA)
checkout_file = hda_element.checkout(username)
operatorName = hda_element.get_short_name()
operatorLabel = (project.get_name() + ' ' + tool.get_name()).title()
saveToLibrary = checkout_file
num_inputs = len(self.hda.inputs())
if copyHDA:
parent = self.hda.parent()
subnet = parent.createNode('subnet')
hda_node = subnet.createDigitalAsset(name=operatorName,
description=operatorLabel,
hda_file_name=saveToLibrary,
min_num_inputs=num_inputs)
hou.copyNodesTo(self.hda.children(), hda_node)
hda_nodeDef = hda_node.type().definition()
hdaDef = self.hda.type().definition()
#Copy over sections
sects = hdaDef.sections()
for sectName in sects:
print 'Copying over section: ' + str(sectName)
hda_nodeDef.addSection(sectName, sects[sectName].contents())
#Copy over NodeGroups
nodeGroups = self.hda.nodeGroups()
for ng in nodeGroups:
newNg = hda_node.addNodeGroup(ng.name())
print 'New group: ' + str(newNg)
for node in ng.nodes():
nodePath = hda_node.path() + '/' + str(node.name())
print 'The Node path is:' + str(nodePath)
newNode = hou.node(nodePath)
if newNode is None:
print('Ya that node was null that is a problem')
continue
print 'The new Node is: ' + str(newNode)
newNg.addNode(newNode)
# Copy over paramters
oldParms = hdaDef.parmTemplateGroup()
hda_nodeDef.setParmTemplateGroup(oldParms)
else:
try:
hda_node = self.hda.createDigitalAsset(
name=operatorName,
description=operatorLabel,
hda_file_name=saveToLibrary,
min_num_inputs=num_inputs)
except hou.OperationFailed, e:
print qd.error('There was a problem creating a digital asset',
details=str(e))
return
viewport.homeAll()
'''
# 02
pointsfromvolume = geo.createNode('pointsfromvolume')
pointsfromvolume.setInput(0, testgeometry_rubbertoy)
pointsfromvolume.setDisplayFlag(True)
# 03
geo_box = hou.node("/obj/box_object")
polybevel = hou.node("/obj/box_object/polybevel1")
testgeometry_rubbertoy.setSelected(True, True)
pointsfromvolume.setSelected(True)
copyNodes = hou.copyNodesTo(hou.selectedNodes(), geo_box)
geo.destroy()
geo = geo_box
testgeometry_rubbertoy = copyNodes[0]
pointsfromvolume = copyNodes[1]
# 04
polybevel.setDisplayFlag(True)
# 05
copytopoints = geo.createNode('copytopoints')
copytopoints.parm("pack").set(True)
copytopoints.setInput(0, polybevel)
copytopoints.setInput(1, pointsfromvolume)
copytopoints.setDisplayFlag(True)
def megaObjDuplicate(node=None, mode="lod"):
"""
duplicates selected node with selected LODs
"""
if not node:
node = hou.pwd()
if mode == "lod":
set_parm = "asset_lod"
select_message = "Select LODs to be created"
select_title = "Select LODs"
elif mode == "asset":
set_parm = "asset"
select_message = "Select asset variations to be created"
select_title = "Select variations"
else:
log.error("wrong mode set")
return
node_pos = node.position()
mega_load_node = MegaUtils.getChildMegaLoad(node)
if not mega_load_node:
log.error("no mega load node found inside of this node")
return
editor = hou.ui.paneTabOfType(hou.paneTabType.NetworkEditor)
orig_path = editor.pwd().path()
my_shader_node = MegaUtils.getChildMaterialAssign(node)
my_shader_multiparm = my_shader_node.parm("num_materials")
my_shader_multiparms = my_shader_multiparm.multiParmInstances()
my_matnet = MegaUtils.getChildMatnet(node)
my_matnet_children = my_matnet.children()
my_lods_parm = mega_load_node.parm(set_parm)
lods = my_lods_parm.menuItems()
my_lod = lods[my_lods_parm.eval()]
lods = list(set(lods) - set([my_lod]))
lods.sort()
selected = hou.ui.selectFromList(choices=lods,
message=select_message,
title=select_title,
clear_on_cancel=True)
if len(selected) == 0:
return
lods = [lods[i] for i in selected]
for i, lod in enumerate(lods):
new_node = hou.copyNodesTo((node, ), node.parent())[0]
new_node.setPosition(node_pos +
hou.Vector2((1 * i + 1, -1 * i - 1)))
mega_node_child = MegaUtils.getChildMegaLoad(new_node)
child_lods = mega_node_child.parm(set_parm).menuItems()
mega_node_child.parm(set_parm).set(child_lods.index(lod))
mega_node_child.parm("reload").pressButton()
new_node.parm("rename").pressButton()
new_node_shader = MegaUtils.getChildMaterialAssign(new_node)
new_node_shader_multiparm = new_node_shader.parm("num_materials")
new_node_shader_multiparm.setFromParm(my_shader_multiparm)
new_node_shader_multiparms = new_node_shader_multiparm.multiParmInstances(
)
for i, parm in enumerate(new_node_shader_multiparms):
try:
if parm.parmTemplate().stringType(
) == hou.stringParmType.NodeReference:
path = my_shader_multiparms[i].evalAsNode().path()
parm.set(path)
else:
parm.setFromParm(my_shader_multiparms[i])
except AttributeError:
parm.setFromParm(my_shader_multiparms[i])
new_matnet = MegaUtils.getChildMatnet(new_node)
new_matnet_children = new_matnet.children()
for new_matnet_child in new_matnet_children:
new_matnet_child.destroy()
new_matnet.copyItems(my_matnet_children)
node.setColor(hou.Color((0, 0, 0)))
editor.cd(orig_path)
def import_objects():
obj_path = ""
obj_folder = None
objsImported = []
this = hou.node('.')
use_mat_path = this.parm('use_mat_path')
# if path is to a directory then we list everything in the directory
# otherwise we'll create a list with one file
is_dir = this.parm('is_dir')
if(is_dir.eval() == True):
obj_path = this.evalParm('file_dir_path')
obj_folder = os.listdir(obj_path)
else:
path_tokens = os.path.split(this.evalParm('file_dir_path'))
obj_path = path_tokens[0] + "/"
obj_folder = [path_tokens[1]]
import_node = hou.node(this.evalParm('path_prefix')).createNode('subnet', this.evalParm('network_name'))
mat_path = this.evalParm('mat_dir_path')
# let's get the path for the instances set up
pntsNodePath = ""
processInstance = this.evalParm('enable_instances')
unpackGeo = this.evalParm('unpack')
if processInstance :
if(this.evalParm('is_file') == False):
pntsNodePath = this.evalParm('instance_pnts_obj')
# create a scene object for copypnts style layout
sceneNode = import_node.createNode('geo', 'scene')
sceneNode.children()[-1].destroy() # delete the file node
sceneNodeMerge = sceneNode.createNode('merge')
# load up the objects
for file in obj_folder:
mmat = None
main_node = None
shaderNames = None
if file.endswith(".abc") or file.endswith(".fbx") or file.endswith(".obj") or file.endswith(".bgeo"):
filename = file.split('.')
obj_node = import_node.createNode("geo", filename[0])
obj_node.createNode("shopnet", "materials");
isPntsNode = False
# if the points node is a file we have to see if the node we're creating here is it
if(processInstance):
if(this.evalParm('is_file') == True):
path_tokens = os.path.split(this.evalParm('instance_pnts_file'))
pntsName = path_tokens[1].split('.')
if(pntsName[0] == obj_node.name()):
pntsNodePath = obj_node.path()
isPntsNode = True
obj_node.parm('vm_renderpoints').set(0) # turn off point rendering
if(not isPntsNode):
objsImported.append(obj_node)
file_node = None
print "Processing " + filename[0]
# if the file is an abc node we'll create an alembic node instead of using the file node
if file.endswith(".abc"):
obj_node.node("file1").destroy()
file_node = obj_node.createNode("alembic")
file_node.parm("fileName").set(obj_path + file)
# we can only do the material assignment stuff on abc files, because that's the only type of file that has paths
xform = obj_node.createNode("xform")
xform.setFirstInput(file_node)
xform.parm('scale').set(this.parm('import_scale').eval())
xform.setDisplayFlag(True)
xform.setRenderFlag(True)
geoNode = None
if unpackGeo or isPntsNode:
unpack = obj_node.createNode("unpack")
unpack.setFirstInput(xform)
unpack.parm('transfer_attributes').set("path")
unpack.setDisplayFlag(True)
unpack.setRenderFlag(True)
geoNode = unpack
else:
geoNode = xform
# see if materials exist and if so load them
matfile = mat_path + filename[0] + ".json"
if os.path.isfile(matfile):
#print "Processing " + matfile
# Import material assignments
mmat = obj_node.createNode('material', 'geo_material')
gmat = obj_node.createNode('material', 'pgrp_material')
mmat.setFirstInput(geoNode)
gmat.setFirstInput(mmat)
shaderNames = material_assign_import(file_node.path(), mmat.path(), gmat.path(), matfile, use_mat_path)
gmat.setDisplayFlag(True)
gmat.setRenderFlag(True)
else:
file_node = obj_node.node("file1")
file_node.parm("file").set(obj_path + file)
obj_node.layoutChildren()
# see if arnold materials exist and if so load them
assfile = mat_path + filename[0] + ".ass"
if os.path.isfile(assfile):
#print "Processing " + assfile
arnold_material_import(assfile, obj_node.path() + "/materials", shaderNames)
hou.node(obj_node.path() + "/materials").layoutChildren()
#print "Processed " + filename[0]
# now that the objects are loaded we can actually run through creating instance nodes for them
if processInstance:
pntsNode = hou.node(pntsNodePath)
# add our name loading and transform extract chain to the points network
hou.copyNodesTo(hou.node(this.path() + "/pnts_node_chain").children(), pntsNode)
hou.node(pntsNode.path() + "/attribwrangle2").setFirstInput(hou.node(pntsNode.path() + "/unpack1"))
pntsNode.layoutChildren()
# create the object merge used to bring in instanced points
# for new style instances
objMergePnts = sceneNode.createNode('object_merge', pntsNode.name())
objMergePnts.parm('objpath1').set('../../' + pntsNode.name())
objMergePnts.parm('xformtype').set(1) # into this object
instanceObjs = []
# loop through instance objects
for obj in objsImported:
obj.setDisplayFlag(False)
# creates new style instances
objMergeAsset = sceneNode.createNode('object_merge', obj.name())
objMergeAsset.parm('objpath1').set('../../' + obj.name())
objMergeAsset.parm('xformtype').set(1) # into this object
pntsDelete = sceneNode.createNode("delete")
pntsDelete.setFirstInput(objMergePnts)
pntsDelete.parm('negate').set(1) # delete non selected
pntsDelete.parm('entity').set(1) # points
pntsDelete.parm('group').set('@name="' + obj.name() + '*"') # set group
copyToPnts = sceneNode.createNode('copytopoints')
copyToPnts.setFirstInput(objMergeAsset)
copyToPnts.setNextInput(pntsDelete)
sceneNodeMerge.setNextInput(copyToPnts)
# creates old style instances
instance = import_node.createNode('instance', 'instance_' + obj.name())
print instance.children()[-1]
instance.children()[-1].destroy() # delete the add node
instance.parm('ptinstance').set(2) # fast point instancing
instance.parm('instancepath').set('../' + obj.name())
instance_merge = instance.createNode('object_merge')
instance_merge.parm('xformtype').set(1) # into this object
instance_merge.parm('objpath1').set('../../' + pntsNode.name())
instance_delete = instance.createNode("delete")
instance_delete.setFirstInput(instance_merge)
instance_delete.parm('negate').set(1) # delete non selected
instance_delete.parm('entity').set(1) # points
instance_delete.parm('group').set('@name="' + obj.name() + '*"') # set group
instance_delete.setDisplayFlag(True)
instance_delete.setRenderFlag(True)
instance.layoutChildren()
instanceObjs.append(instance)
import_node.layoutChildren(instanceObjs)
instancesBox = import_node.createNetworkBox()
instancesBox.setComment('Instances')
for instance in instanceObjs:
instancesBox.addNode(instance)
instancesBox.fitAroundContents()
import_node.layoutChildren()
child.parm('rx').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('ry').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('rz').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('tx').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('ty').setExpression('chop("../CHOP/OUT/$OS:$CH")')
child.parm('tz').setExpression('chop("../CHOP/OUT/$OS:$CH")')
rigBox.addNode(child)
if child.type().name() == 'bone':
# add the bones to the rig net box
rigBox.addNode(child)
if child.type().name() == 'geo':
if child.name() is not charGeo.name():
# we want to convert these to a single geo pointing to a alembic
hou.copyNodesTo(child.children(), charGeo)
child.destroy()
rigBox.fitAroundContents()
# build the CHOP network
child = selNode.createNode('chopnet', 'CHOP')
#let's fetch the original tpose and place in in a bclip
fetch = child.createNode('fetch')
fetch.parm('rate').set(24)
fetch.parm('nodepath').set('../../* ')
bclip = fetch.clipData(True)
fileName = hou.ui.selectFile(None, "Select tpose export location...")
