def parameters_ui(self):
# opening the template group
tg_parms = self.rig_subnet.parmTemplateGroup()
ch_p_folder_parms = hou.FolderParmTemplate(self.node.name()+"character_placer", "character_placer")
# creating the parms
for i in self.limb_subnet.children():
hou_parm_template = hou.FloatParmTemplate(i.name()+"_t", "Translate", 3, default_value=([0, 0, 0]),
min=0, max=10, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular,
naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.FloatParmTemplate(i.name()+"_r", "Rotate", 3, default_value=([0, 0, 0]), min=0,
max=360, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.FloatParmTemplate(i.name()+"_s", "Scale", 3, default_value=([1, 1, 1]), min=0,
max=10, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.FloatParmTemplate(i.name()+"_p", "Pivot", 3, default_value=([0, 0, 0]), min=0,
max=10, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.SeparatorParmTemplate(i.name()+"_sep")
ch_p_folder_parms.addParmTemplate(hou_parm_template)
#finding the folder to put the parms and closing the template
folder_node = tg_parms.findFolder(["Rig Parms"])
tg_parms.appendToFolder(folder_node, ch_p_folder_parms)
self.rig_subnet.setParmTemplateGroup(tg_parms)
def add_TMP(attr_name, tmp_type, current_tmpparm, language_dict=None):
attr_label = attr_name
if language_dict:
attr_label = language_dict.get(attr_name, attr_name)
if tmp_type == "FloatParmTemplate":
current_tmpparm.append(hou.FloatParmTemplate(attr_name, attr_label, 1))
elif tmp_type == "RampParmTemplate":
current_tmpparm.append(
hou.RampParmTemplate(attr_name,
attr_label,
hou.rampParmType.Float,
default_value=2,
default_basis=None,
color_type=None))
elif tmp_type == "IntParmTemplate":
current_tmpparm.append(hou.IntParmTemplate(attr_name, attr_label, 1))
elif tmp_type == "StringParmTemplate":
current_tmpparm.append(hou.StringParmTemplate(attr_name, attr_label,
1))
elif tmp_type == "ToggleParmTemplate":
current_tmpparm.append(hou.ToggleParmTemplate(attr_name, attr_label,
0))
elif tmp_type == "SeparatorParmTemplate":
current_tmpparm.append(
hou.SeparatorParmTemplate(attr_name, attr_label, 1))
return current_tmpparm
def parm_create(node, type, name, label):
if type == "integer":
new_template = hou.IntParmTemplate(name, name, 1)
if type == "toggle":
new_template = hou.ToggleParmTemplate(name, name)
if type == "float":
new_template = hou.FloatParmTemplate(name, name, 1)
if type == "vector":
new_template = hou.FloatParmTemplate(name, name, 3)
new_template.setLook(hou.parmLook.Regular)
if type == "color":
new_template = hou.FloatParmTemplate(name, name, 3)
new_template.setNamingScheme(hou.parmNamingScheme.RGBA)
new_template.setLook(hou.parmLook.ColorSquare)
if type == "string":
new_template = hou.StringParmTemplate(name, label, 1)
new_template.setStringType(hou.stringParmType.Regular)
if type == "file":
new_template = hou.StringParmTemplate(name, name, 1)
new_template.setStringType(hou.stringParmType.FileReference)
if type == "node":
new_template = hou.StringParmTemplate(name, name, 1)
new_template.setStringType(hou.stringParmType.NodeReference)
if type == "separator":
new_template = hou.SeparatorParmTemplate(name)
if type == "label":
new_template = hou.LabelParmTemplate(name, label, [label], False, True)
if type == "rampfloat":
new_template = hou.RampParmTemplate(name, name, hou.rampParmType.Float)
new_template.setShowsControls(False)
if type == "rampcolor":
new_template = hou.RampParmTemplate(name, name, hou.rampParmType.Color)
new_template.setShowsControls(False)
try:
ptg = node.parmTemplateGroup()
ptg.addParmTemplate(new_template)
node.setParmTemplateGroup(ptg)
existed = 0
except:
existed = 1
def CreateCanoeRenderTab(n):
ptg = n.parmTemplateGroup()
folder = hou.FolderParmTemplate("shortcuts", "CANOE")
Render_Cam = hou.StringParmTemplate(
"RS_renderCamera2",
"Render Camera",
1,
default_value=(["/obj/RS_Cam"]),
string_type=hou.stringParmType.NodeReference)
Render_Cam.setTags({
"autoscope": "0000000000000000",
"opfilter": "!!OBJ/CAMERA!!",
"oprelative": "."
})
folder.addParmTemplate(Render_Cam)
Output = hou.StringParmTemplate(
"RS_outputFileNamePrefix2",
"Common File Prefix",
1,
default_value=(["$JOB/Render/001_InitRender/$F4.exr"]),
string_type=hou.stringParmType.FileReference,
item_generator_script="opmenu -l . RS_outputFileNamePrefix",
item_generator_script_language=hou.scriptLanguage.Hscript,
menu_type=hou.menuType.StringReplace)
folder.addParmTemplate(Output)
folder.addParmTemplate(hou.SeparatorParmTemplate("sep1"))
arhive_toggle = hou.ToggleParmTemplate(
"RS_archive_enable2",
"Export .rs Proxy File",
default_value=False,
default_expression='off',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(arhive_toggle)
archive = hou.StringParmTemplate(
"RS_archive_file2",
"Filename",
1,
default_value=(["$HIP/filename.$F4.rs"]),
naming_scheme=hou.parmNamingScheme.Base1,
string_type=hou.stringParmType.FileReference,
item_generator_script="opmenu -l . RS_archive_file",
item_generator_script_language=hou.scriptLanguage.Hscript,
menu_type=hou.menuType.StringReplace)
folder.addParmTemplate(archive)
folder.addParmTemplate(hou.SeparatorParmTemplate("sep2"))
Motion_toggle = hou.ToggleParmTemplate(
"MotionBlurEnabled2",
"Enable Motion Blur",
default_value=False,
default_expression='off',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(Motion_toggle)
Fog_toggle = hou.ToggleParmTemplate(
"VolLightingEnabled2",
"Enable Global Fog",
default_value=False,
default_expression='off',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(Fog_toggle)
AOV_toggle = hou.ToggleParmTemplate(
"RS_aovAllAOVsDisabled2",
"Disable All AOVs",
default_value=True,
default_expression='on',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(AOV_toggle)
Tesselation_Toggle = hou.ToggleParmTemplate(
"TessellationDisplacementEnable2",
"Enable Tessellation And Displacement",
default_value=True,
default_expression='on',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(Tesselation_Toggle)
folder.addParmTemplate(hou.SeparatorParmTemplate("sep3"))
# Code for parameter template
# Deadline Parameters
deadline_priority = hou.IntParmTemplate("deadline_priority",
"Deadline Priority",
1,
default_value=([50]),
min=1,
max=90,
min_is_strict=True,
max_is_strict=True)
folder.addParmTemplate(deadline_priority)
deadline_jobname = hou.StringParmTemplate("deadline_jobname",
"Deadline Jobname",
1,
default_value=(["$HIPNAME"]))
folder.addParmTemplate(deadline_jobname)
DeadlineFastRender_btn = hou.ButtonParmTemplate(
"submit_to_deadline_allGpus", "Deadline Render")
DeadlineFastRender_btn.setScriptCallback(
"import lz;lz.lzDeadline.submitRS2Deadline(hou.pwd(),one_task_per_gpu=False)"
)
DeadlineFastRender_btn.setScriptCallbackLanguage(hou.scriptLanguage.Python)
folder.addParmTemplate(DeadlineFastRender_btn)
DeadlineRender_btn = hou.ButtonParmTemplate(
"submit_to_deadline", "Deadline Render (1f per GPU)")
DeadlineRender_btn.setScriptCallback(
"import lz;lz.lzDeadline.submitRS2Deadline(hou.pwd())")
DeadlineRender_btn.setScriptCallbackLanguage(hou.scriptLanguage.Python)
folder.addParmTemplate(DeadlineRender_btn)
BatchProxy_btn = hou.ButtonParmTemplate("batch_proxy", "Batch Proxy")
BatchProxy_btn.setScriptCallback(
"import hou;hou.hipFile.save();import lz;lz.lzRS_Shelf.BatchProxy(hou.pwd())"
)
BatchProxy_btn.setScriptCallbackLanguage(hou.scriptLanguage.Python)
folder.addParmTemplate(BatchProxy_btn)
before = "RS_rrs2"
ptg.insertAfter(before, folder)
n.setParmTemplateGroup(ptg)
parms = [
"RS_renderCamera", "RS_outputFileNamePrefix", "RS_archive_enable",
"RS_archive_file", "MotionBlurEnabled", "VolLightingEnabled",
"RS_aovAllAOVsDisabled", "TessellationDisplacementEnable"
]
for parm in parms:
n.parm(parm).set(n.parm(parm + "2"))
def resizeFluidSops(kwargs):
""" Select fluid and set it up to be resizeable.
"""
sceneviewer = toolutils.activePane(kwargs)
if not isinstance(sceneviewer, hou.SceneViewer):
raise hou.Error("Invalid pane type for this operation.")
# Select the target fluid box.
fluidobjects = sceneviewer.selectDynamics(
prompt="Select fluid box to resize. Press Enter to complete.",
allow_multisel=False)
if len(fluidobjects) < 1:
raise hou.Error(
"No fluid container selected to set initial conditions.")
fluidobject = fluidobjects[0]
fluidnode = doptoolutils.getDopObjectCreator(fluidobject)
if fluidnode is None:
raise hou.Error("No fluid object node found.")
""" Create and configure the reference container for resizing.
"""
dopnet = doptoolutils.getCurrentDopNetwork()
refobject = fluidnode.parent().parent().createNode(
"geo", "fluid_resize_container", run_init_scripts=False)
fluidfields = refobject.createNode("dopio", "fluidfields")
fluidfields.parm("doppath").set(dopnet.path())
fluidfields.setParmExpressions(
{"defobj": "chs(\"" + fluidnode.path() + "/object_name\")"})
fluidfields.parm("fields").set(2)
fluidfields.parm("fieldname1").set("density")
fluidfields.parm("fieldname2").set("vel")
parms = refobject.parmTemplateGroup()
parms.hideFolder("Transform", True)
parms.hideFolder("Material", True)
parms.hideFolder("Render", True)
parms.hideFolder("Misc", True)
ref_folder = hou.FolderParmTemplate("ref_folder", "Resize Container")
ref_folder.addParmTemplate(
hou.IntParmTemplate(
"nptsperarea",
"Scatter per Area",
1,
default_value=([5000]),
min=1000,
max=20000,
help="Scatter points on simulated density to calculate bounds"))
ref_folder.addParmTemplate(
hou.FloatParmTemplate(
"treshold",
"Density Treshold",
1,
default_value=([0]),
min=0,
max=1,
help="Delete density below this value prior to scattering points"))
ref_folder.addParmTemplate(hou.SeparatorParmTemplate("sep1"))
ref_folder.addParmTemplate(
hou.LabelParmTemplate("merge_source", "Merge Sources"))
ref_folder.addParmTemplate(
hou.ButtonParmTemplate(
"update",
"Update sources",
help="Push this to update ObjectMerge node inside",
tags={
"script_callback":
"import adddoputils; adddoputils.updateSourcesButton()",
"script_callback_language": "python"
}))
ref_folder.addParmTemplate(
hou.IntParmTemplate(
"source_activation",
"All Sources Activation",
1,
default_value=([1]),
min=0,
max=1,
min_is_strict=True,
max_is_strict=True,
help=
"Activation of merging all of the listed sources and additional objects"
))
ref_folder.addParmTemplate(
hou.MenuParmTemplate(
"xformtype", "Transform", "012",
("None", "Into This Object", "Into Specified Object"), 1))
ref_folder.addParmTemplate(
hou.StringParmTemplate("xformpath",
"Transform object",
1,
"",
hou.parmNamingScheme.Base1,
hou.stringParmType.NodeReference,
disable_when=("{ xformtype != 2 }")))
sources_folder = hou.FolderParmTemplate(
"source_folder",
"Sources to Merge",
folder_type=hou.folderType.MultiparmBlock)
sources_folder.addParmTemplate(
hou.ToggleParmTemplate("source_activation#",
"Source # Activation",
default_value=True))
sources_folder.addParmTemplate(
hou.StringParmTemplate("objpath#", "Object #", 1, "",
hou.parmNamingScheme.Base1,
hou.stringParmType.NodeReference))
sources_folder.addParmTemplate(
hou.StringParmTemplate("group#", "Group #", 1, "",
hou.parmNamingScheme.Base1,
hou.stringParmType.Regular))
ref_folder.addParmTemplate(sources_folder)
parms.append(ref_folder)
refobject.setParmTemplateGroup(parms)
keep_density = refobject.createNode("blast", "keep_density")
keep_density.setFirstInput(fluidfields)
keep_density.parm("group").set("@name==vel*")
keep_vel = refobject.createNode("blast", "keep_vel")
keep_vel.setFirstInput(fluidfields)
keep_vel.parm("group").set("@name==density")
# VOLUME VOP clamping density field below given treshold
density_treshold = keep_density.createOutputNode("volumevop",
"density_treshold")
vopglobals = density_treshold.node("volumevopglobal1")
treshold = density_treshold.createNode("parameter", "treshold")
treshold.parm("parmname").set("treshold")
treshold.parm("parmlabel").set("Treshold")
compare_density = density_treshold.createNode("compare", "compare_density")
compare_density.parm("cmp").set("gte")
compare_density.setInput(0, vopglobals, 1)
compare_density.setInput(1, treshold, 0)
twoway = compare_density.createOutputNode("twoway", "switch_density")
twoway.setInput(1, vopglobals, 1)
vop_output = density_treshold.node("volumevopoutput1")
vop_output.setFirstInput(twoway, 0)
density_treshold.setParmExpressions({"treshold": "ch(\"../treshold\")"})
# End of VOLUME VOP
scatter = refobject.createNode("scatter", "scatter")
scatter.setFirstInput(density_treshold)
scatter.parm("ptsperarea").set(1)
scatter.setParmExpressions({"nptsperarea": "ch(\"../nptsperarea\")"})
add_particles = scatter.createOutputNode("add", "add_particles")
add_particles.parm("addparticlesystem").set(1)
# VOP SOP adding velocity field to density-based pointcloud
add_vel = refobject.createNode("vopsop", "add_vel")
add_vel.parm("vex_numthreads").set(1)
add_vel.setFirstInput(add_particles)
add_vel.setInput(1, keep_vel, 0)
globals = add_vel.node("global1")
volumesamplex = add_vel.createNode("volumesample", "volumesample_x")
volumesamplex.setInput(2, globals, 0)
volumesamplex.parm("input_index").set(1)
volumesamplex.parm("primnum").set(0)
volumesampley = add_vel.createNode("volumesample", "volumesample_y")
volumesampley.setInput(2, globals, 0)
volumesampley.parm("input_index").set(1)
volumesampley.parm("primnum").set(1)
volumesamplez = add_vel.createNode("volumesample", "volumesample_z")
volumesamplez.setInput(2, globals, 0)
volumesamplez.parm("input_index").set(1)
volumesamplez.parm("primnum").set(2)
vel = volumesamplex.createOutputNode("floattovec", "vel")
vel.setInput(1, volumesampley, 0)
vel.setInput(2, volumesamplez, 0)
vel_by_fps = vel.createOutputNode("divconst", "vel_by_fps")
vel_by_fps.setParmExpressions({"divconst": "$FPS"})
add_vector = globals.createOutputNode("add", "add_vector")
add_vector.setNextInput(vel_by_fps, 0)
vex_output = add_vel.node("output1")
vex_output.setFirstInput(add_vector, 0)
# End of VOP SOP
merge1 = refobject.createNode("merge", "merge1")
merge1.setFirstInput(add_particles)
merge1.setInput(1, add_vel, 0)
bound = merge1.createOutputNode("bound", "bound")
# Box to switch from after first simulation frame
initial_box = refobject.createNode("box", "initial_box")
initial_box.setParmExpressions({
"sizex":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/sizex\")",
"sizey":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/sizey\")",
"sizez":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/sizez\")"
})
initial_box.setParmExpressions({
"tx":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/tx\")",
"ty":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/ty\")",
"tz":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/tz\")"
})
initial_switch = initial_box.createOutputNode("switch", "initial_switch")
initial_switch.setParmExpressions({
"input":
"$F>ch(\"" + initial_switch.relativePathTo(fluidnode) +
"/createframe\")",
})
initial_switch.setInput(1, bound, 0)
# Null to switch to if merging of simulation sources is disabled
no_active_source = refobject.createNode("null", "no_active_source")
merge_source = refobject.createNode("object_merge", "merge_source")
merge_source.setParmExpressions({
"numobj": "ch(\"../source_folder\")",
"xformtype": "ch(\"../xformtype\")"
})
merge_source.parm("xformpath").set("`chsop(\"../xformpath\")`")
numobj = merge_source.parm("numobj").eval()
source_switch = no_active_source.createOutputNode("switch",
"source_switch")
source_switch.setParmExpressions({"input": "ch(\"../source_activation\")"})
source_switch.setInput(1, merge_source, 0)
merge2 = initial_switch.createOutputNode("merge", "merge2")
merge2.setInput(1, source_switch, 0)
bound = merge2.createOutputNode("bound", "bound")
unroll_edges = bound.createOutputNode("ends", "unroll_edges")
unroll_edges.parm("closeu").set(4)
out = unroll_edges.createOutputNode("null", "OUT")
density_treshold.layoutChildren()
add_vel.layoutChildren()
refobject.layoutChildren()
out.setDisplayFlag(True)
out.setRenderFlag(True)
resize = resizeFluidToMatchSops(fluidnode, refobject)
resize.setCurrent(True, True)
sceneviewer.enterCurrentNodeState()
def _addProperties(node):
""" Create all required parameters.
:hou.HDADefinition node: the node receiving the new parameters.
"""
parmTemplateGroup = node.parmTemplateGroup()
if parmTemplateGroup.findFolder('Walter'):
return
addArnoldProperties(node, force=True)
# To Get the lattest parmTemplateGroup with the Arnold group.
parmTemplateGroup = node.parmTemplateGroup()
parmName = 'ar_filename'
dsoParm = hou.StringParmTemplate(parmName,
'Procedural DSO',
1,
default_value=('walterProcedural',),
is_hidden=True)
ar_procedural_type = hou.StringParmTemplate(
'ar_procedural_type',
'Procedural Type',
1,
default_value=('walter',),
is_hidden=True)
ar_translate_as = hou.StringParmTemplate(
'ar_translate_as',
'Translate As',
1,
default_value=('arnold_procedural',),
is_hidden=True)
ar_bounding_box_padding = hou.FloatParmTemplate(
'ar_bounding_box_padding',
'Bounds Padding', 1, is_hidden=True)
ar_data = hou.StringParmTemplate(
'ar_data', 'Data String', 1, is_hidden=True)
user_parms_separator = hou.SeparatorParmTemplate('user_parms_separator')
parmName = 'ar_filePaths'
filePaths = hou.StringParmTemplate(
parmName, 'Layers', 1, default_value=('',), is_hidden=True)
display_mode = hou.MenuParmTemplate(
'display_mode', 'Display Mode', ('0', '1'),
menu_labels=('None', 'Hydra'), default_value=0)
layerPath = hou.StringParmTemplate(
'layerPath#', 'Path', 1, default_value=('',),
string_type=hou.stringParmType.FileReference,
file_type=hou.fileType.Geometry,
tags={'filechooser_pattern': '*.abc *.usd *.usda',
'script_callback' : "kwargs['node'].hdaModule().update(kwargs['node'])",
'script_callback_language': 'python'})
parmName = 'ar_layers'
layers = hou.FolderParmTemplate(
parmName, 'Layers', parm_templates=([layerPath]),
folder_type=hou.folderType.MultiparmBlock,
tags={'script_callback': "kwargs['node'].hdaModule().update(kwargs['node'])",
'script_callback_language': 'python'})
parmName = 'ar_objectPath'
objectPath = hou.StringParmTemplate(
parmName, "Prim Path", 1, default_value=('/',),
join_with_next=True)
pick_path = hou.ButtonParmTemplate(
"pick_path", '', is_label_hidden=True,
tags={'button_icon': 'BUTTONS_tree',
'script_callback':
"kwargs['node'].node('display/walter').parm('pickObjectPath').pressButton()",
'script_callback_language': 'python'})
parmName = 'ar_sessionLayer'
sessionLayer = hou.StringParmTemplate(
parmName, "Session Layer", 1, default_value=('',), is_hidden=True)
parmName = 'ar_mayaStateLayer'
mayaStateLayer = hou.StringParmTemplate(
parmName, 'Maya State Layer', 1, default_value=('',), is_hidden=True)
parms = [dsoParm,
ar_procedural_type,
ar_translate_as,
ar_bounding_box_padding,
ar_data,
user_parms_separator,
filePaths,
display_mode,
layers,
objectPath,
pick_path,
sessionLayer,
mayaStateLayer]
parms = [p for p in parms if p is not None]
walterFolder = hou.FolderParmTemplate(
'walter', 'Walter', parm_templates=(parms),
folder_type=hou.folderType.Tabs, is_hidden=False,
ends_tab_group=False, tags={})
xfo_idx = parmTemplateGroup.findIndicesForFolder('Transform')
parmTemplateGroup.insertBefore(xfo_idx, walterFolder)
node.setParmTemplateGroup(parmTemplateGroup)
})
selNode.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"
})
selNode.addSpareParmTuple(hou_parm_template,
in_folder=(['Cache']),
create_missing_folders=True)
#FBX params
hou_parm_template = hou.SeparatorParmTemplate("sepparm")
selNode.addSpareParmTuple(hou_parm_template,
in_folder=(['Cache']),
create_missing_folders=True)
hou_parm_template = hou.LabelParmTemplate("labelparm2",
"FBX",
column_labels=([""]))
selNode.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"]),
def literalsToParms(nodes):
"""For each node in nodes that has a snippet parameter (e.g. all the wrangle
sops):
Adds a parameter for each variable declared in the code, if that variable
is just assigned a literal. The declaration itself is changed so it
references the created parameter.
e.g. if somewhere in your snippet, you have the line
vector normal = {1,2,3};
a float parameter named 'normal' with 3 components will be created on the
node, with it's default set to 1,2,3. The line in the code will be changed
to:
vector normal = ch("normal");
If the method is run on a node that already has these auto-generated
parameters, it'll updated them:
* change the parameter type if the variable's type has changed in the code
* change the number of components if it has changed in the code
* delete parameters who's corresponding declaration has been removed
* update default values
The parameters are created at the top of the parameter interface,
with a separator below. The separator is called 'auto_generated'. All
parameters above this separator are considered to have been generated by
this script and are fair game for deletion when running the script again.
"""
for node in nodes:
snippet_parm = node.parm('snippet')
if not snippet_parm:
continue
snippet = snippet_parm.eval()
vex_lines = snippet.strip().split("\n")
declarations = _findDeclarations(vex_lines)
parm_type = None
tempGroup = node.parmTemplateGroup()
sep = tempGroup.find('auto_generated')
if not sep:
sep = hou.SeparatorParmTemplate('auto_generated')
tempGroup.insertBefore(tempGroup.entries()[0], sep)
if declarations:
varnames = zip(*declarations)[2]
else:
varnames = []
# delete parameters that are above the auto_generated separator, and not in the list of declared variables
for entry in tempGroup.entries():
if entry.name() == 'auto_generated':
break
elif entry.name() not in varnames:
tempGroup.remove(entry)
for decl in declarations:
linenum, vartype, varname, varvalue = decl
if not varvalue:
continue
template = None
numComps = None
function = None
if vartype == 'float':
template = hou.FloatParmTemplate(varname, varname, 1)
parm_type = template.type()
numComps = 1
function = 'chf'
if vartype == 'int':
template = hou.IntParmTemplate(varname, varname, 1)
parm_type = template.type()
numComps = 1
function = 'ch'
elif vartype == 'vector':
template = hou.FloatParmTemplate(varname, varname, 3)
parm_type = template.type()
numComps = 3
function = 'chv'
elif vartype == 'vector4':
template = hou.FloatParmTemplate(varname, varname, 4)
parm_type = template.type()
numComps = 4
function = 'chv'
elif vartype == 'string':
template = hou.StringParmTemplate(varname, varname, 1)
parm_type = template.type()
numComps = 1
function = 'chs'
if parm_type == hou.parmTemplateType.Float:
valtype = float
else:
valtype = int
print decl
if vartype == 'string':
varvalue = [varvalue[1:-1]] # strip quotes, wrap in list
else:
g = re.match(r"[\{\s]*([0-9\.\ f\,]*).*", varvalue).groups()[0]
varvalue = [valtype(comp) for comp in g.split(',')]
if template:
existing_template = tempGroup.find(varname)
if not existing_template:
pass
elif existing_template.type() != parm_type:
existing_template = None
tempGroup.remove(varname)
elif existing_template.numComponents() != numComps:
existing_template = None
tempGroup.remove(varname)
else:
template = existing_template
template.setNumComponents(numComps)
template.setDefaultValue(varvalue)
if not existing_template:
tempGroup.insertBefore(sep, template)
if template == existing_template:
tempGroup.replace(varname, template)
vex_lines[linenum] = "%s %s = %s(\"%s\");" % (
vartype, varname, function, varname)
node.setParmTemplateGroup(tempGroup)
new_code = "\n".join(vex_lines)
snippet_parm.set(new_code)
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 list_of_parms_to_promote_to_ui(list_of_nodes, list_of_desire_parms, node_to_parm=None, into_this_folder=[],
separator_line=True):
"""
@param list_of_nodes: list of the nodes that you want to loop
@param list_of_desire_parms: list of the parameters of the nodes that you want to promote
@param node_to_parm: what the node where you want to promote this parameters
@param into_this_folder: whats the folder where you want to put them
@param separator_line: will create a line after each node, True or False
@return:
@example:
hou_rig.utils.list_of_parms_to_promote_to_ui(nodes_trans_to_promote,
[["t", "tuple", "jwnp"],
["r", "tuple", "jwnp"],
["scale", "parm", "jwnp","label=this_is_label"]],
node_to_parm=node_to_put,
into_this_folder=folder_to_put_in+["Muscle Trans"])
"""
#todo put a label in front of the separator_line with the name of the node
for i in list_of_nodes:
for j in list_of_desire_parms:
if j[1] == "parm":
parm = i.parm(j[0])
elif j[1] == "tuple":
parm = i.parmTuple(j[0])
jwnp = False
for itn in j:
if itn == "jwnp":
# print itn
jwnp = True
if "label" in str(itn):
label = itn.split("=")[1]
else:
label = False
if label is False:
promote_parm_to_ui(parm,
node_to_parm,
in_this_folder=into_this_folder,
parm_name=i.parent().name() + "_" + i.name() + "_" + j[0],
ch_link=True,
join_with_next_parm=jwnp)
else:
promote_parm_to_ui(parm,
node_to_parm,
in_this_folder=into_this_folder,
parm_name=i.parent().name() + "_" + i.name() + "_" + j[0],
parm_label=label,
ch_link=True,
join_with_next_parm=jwnp)
if separator_line is True:
loop = 0
while True:
try:
separator_parm = hou.SeparatorParmTemplate(
i.parent().name() + "_" + i.name() + "separator" + str(loop))
parm_to_ui(node_to_parm, separator_parm, in_this_folder=into_this_folder)
break
except:
loop += 1
