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 hda_parameter_setup(hda, geo, project):
parmGroup = hda.parmTemplateGroup()
projectName = project.get_name().lower().replace(' ', '_')
projectFolder = hou.FolderParmTemplate(projectName, project.get_name(), folder_type=hou.folderType.Tabs, default_value=0, ends_tab_group=False)
source_menu = hou.MenuParmTemplate('source', 'Source', ('set', 'animated', 'object_space'), menu_labels=('Set', 'Animated', 'Object Space'), default_value=2)
source_menu_index = hou.IntParmTemplate('source_index', 'Source Index', 1, is_hidden=True, default_expression=('ch("source")',))
projectFolder.addParmTemplate(source_menu)
projectFolder.addParmTemplate(source_menu_index)
cook_script='hou.node("./' + geo.name() + '").parm("cook").pressButton()\nprint "Asset Refreshed"'
projectFolder.addParmTemplate(create_shot_menu(hideWhen='source_index != 1', callback_script=cook_script))
projectFolder.addParmTemplate(create_set_menu(hideWhen='source_index != 0', callback_script=cook_script))
hide_toggle = hou.ToggleParmTemplate('hide', 'Hide')
projectFolder.addParmTemplate(hide_toggle)
recook = hou.ButtonParmTemplate('re_cook_hda', 'Reload', script_callback=cook_script, script_callback_language=hou.scriptLanguage.Python)
projectFolder.addParmTemplate(recook)
version = hou.IntParmTemplate('abcversion', 'Alembic Version', 1)
projectFolder.addParmTemplate(version)
lightlink = hou.StringParmTemplate("lightmask", "Light Mask", 1, default_value=(["*"]), string_type=hou.stringParmType.NodeReferenceList) #, menu_items=([]), menu_labels=([]), icon_names=([]))
lightlink.setTags({"opfilter": "!!OBJ/LIGHT!!", "oprelative": "/"})
projectFolder.addParmTemplate(lightlink)
auto_archive = hou.properties.parmTemplate(get_latest_prman(),"ri_auto_archive")
auto_archive.setDefaultValue(("exist",))
projectFolder.addParmTemplate(auto_archive)
parmGroup.addParmTemplate(projectFolder)
hda.type().definition().setParmTemplateGroup(parmGroup)
hda.parm("ri_auto_archive").set("force")
return hda
def createAaNoiseFolderParmTemplate(id):
a_parm = hou.FloatParmTemplate('a' + id,
'Amp' + id,
1,
default_value=(1, ))
f_parm = hou.FloatParmTemplate('f' + id,
'Freq' + id,
1,
default_value=(1, ))
t_parm = hou.IntParmTemplate('t' + id, 'Turb' + id, 1, default_value=(3, ))
o_parm = hou.FloatParmTemplate('o' + id,
'Offset' + id,
1,
default_value=(0, ))
r_parm = hou.FloatParmTemplate('r' + id,
'Rough' + id,
1,
default_value=(0.5, ))
xnoise = hou.ToggleParmTemplate('type' + id, 'Xnoise' + id, 1)
noise_folder = hou.FolderParmTemplate('noise'+id,'Noise'+id,\
parm_templates = (a_parm,f_parm,t_parm,o_parm,r_parm,xnoise),\
folder_type = hou.folderType.Simple)
return noise_folder
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 boolParm(p, parent=None):
name = parmName(p.name, prefix=parent)
label = parmLabel(p)
default = p.defaultValue.value
parm = hou.ToggleParmTemplate(name,
label,
default_value=default,
disable_when="",
help=p.description)
return {'name': name, 'tuple': parm, 'initialValue': [p.getTypedValue()]}
def imprint(node, data):
"""Store attributes with value on a node
Depending on the type of attribute it creates the correct parameter
template. Houdini uses a template per type, see the docs for more
information.
http://www.sidefx.com/docs/houdini/hom/hou/ParmTemplate.html
Args:
node(hou.Node): node object from Houdini
data(dict): collection of attributes and their value
Returns:
None
"""
parm_group = node.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate("folder", "Extra")
for key, value in data.items():
if value is None:
continue
if isinstance(value, float):
parm = hou.FloatParmTemplate(name=key,
label=key,
num_components=1,
default_value=(value, ))
elif isinstance(value, bool):
parm = hou.ToggleParmTemplate(name=key,
label=key,
default_value=value)
elif isinstance(value, int):
parm = hou.IntParmTemplate(name=key,
label=key,
num_components=1,
default_value=(value, ))
elif isinstance(value, six.string_types):
parm = hou.StringParmTemplate(name=key,
label=key,
num_components=1,
default_value=(value, ))
else:
raise TypeError("Unsupported type: %r" % type(value))
parm_folder.addParmTemplate(parm)
parm_group.append(parm_folder)
node.setParmTemplateGroup(parm_group)
def c_staticmodel(n):
group = n.parmTemplateGroup()
folder = hou.FolderParmTemplate("folder", "Static Model Component")
folder.addParmTemplate(hou.StringParmTemplate("model", "Model", 1))
folder.addParmTemplate(hou.StringParmTemplate("material", "Material",1))
folder.addParmTemplate(hou.ToggleParmTemplate("isoccluder", "Is Occluder", 0))
folder.addParmTemplate(hou.ToggleParmTemplate("isoccludable", "Can Be Occluded", 1))
folder.addParmTemplate(hou.ToggleParmTemplate("castshadows", "Cast Shadows", 0))
folder.addParmTemplate(hou.FloatParmTemplate("drawdistance", "Draw Distance", 1 ) )
folder.addParmTemplate(hou.FloatParmTemplate("shadowdistance", "Shadow Distance", 1 ) )
folder.addParmTemplate(hou.FloatParmTemplate("lodbias", "LOD Bias", 1 ,(1.0,)) )
folder.addParmTemplate(hou.FloatParmTemplate("maxlights", "Max Lights", 1 ) )
folder.addParmTemplate(hou.IntParmTemplate("viewmask", "View Mask",1,(-1,)))
folder.addParmTemplate(hou.IntParmTemplate("lightmask", "Light Mask",1,(-1,)))
folder.addParmTemplate(hou.IntParmTemplate("shadowmask", "Shadow Mask",1,(-1,)))
folder.addParmTemplate(hou.IntParmTemplate("zonemask", "Zone Mask",1,(-1,)))
folder.addParmTemplate(hou.IntParmTemplate("occlodlevel", "Occ LOD Level",1,(-1,)))
group.append(folder)
n.setParmTemplateGroup(group)
def _add_using_next_parm(self, node, parameter_group):
"""
Add special parameter to node to store the last state of the version drop down.
:param node: A :class:`hou.Node` instance.
:param parameter_group: The node's :class:`ParmGroup`.
"""
using_next = hou.ToggleParmTemplate(
self.USING_NEXT_VERSION,
"using next version",
default_value=True,
is_hidden=True,
)
parameter_group.append_template(using_next)
def c_rigidbody(n):
group = n.parmTemplateGroup()
folder = hou.FolderParmTemplate("folder", "Rigid Body Component")
folder.addParmTemplate(hou.FloatParmTemplate("mass", "Mass",1))
folder.addParmTemplate(hou.FloatParmTemplate("friction", "Friction",1,(0.5,)))
folder.addParmTemplate(hou.FloatParmTemplate("anifriction", "Anistropic Friction",3,(1.0,1.0,1.0,)))
folder.addParmTemplate(hou.FloatParmTemplate("rollfriction", "Rolling Friction",1))
folder.addParmTemplate(hou.FloatParmTemplate("restitution", "Restitution",1))
folder.addParmTemplate(hou.FloatParmTemplate("linearvelocity", "Linear Velocity",3))
folder.addParmTemplate(hou.FloatParmTemplate("angularvelocity", "Angular Velocity",3))
folder.addParmTemplate(hou.FloatParmTemplate("linearfactor", "Linear Factor",3,(1.0,1.0,1.0,)))
folder.addParmTemplate(hou.FloatParmTemplate("angularfactor", "Angular Factor",3,(1.0,1.0,1.0,)))
folder.addParmTemplate(hou.FloatParmTemplate("lineardamping", "Linear Damping",1))
folder.addParmTemplate(hou.FloatParmTemplate("angulardamping", "Angular Damping",1))
folder.addParmTemplate(hou.FloatParmTemplate("linearrest", "Linear Rest Threshold",1,(0.8,)))
folder.addParmTemplate(hou.FloatParmTemplate("angluarrest", "Angular Rest Threshold",1,(1.0,)))
folder.addParmTemplate(hou.IntParmTemplate("collisionlayer", "Collision Layer",1,(1,)))
folder.addParmTemplate(hou.IntParmTemplate("collisionmask", "Collision Mask",1,(-1,)))
folder.addParmTemplate(hou.FloatParmTemplate("contactthreshold", "Contact Threshold",1,(1e+18,)))
folder.addParmTemplate(hou.FloatParmTemplate("ccdradius", "CCD Radius",1))
folder.addParmTemplate(hou.FloatParmTemplate("ccdmotion", "CCD Motion Threshold",1))
#This needs to be a drop down
#never, when active, always
folder.addParmTemplate(hou.MenuParmTemplate("collisioneventmode", "Collision Event Mode",("Never","When Active","Always",),default_value=1))
folder.addParmTemplate(hou.ToggleParmTemplate("usegravity", "Use Gravity", 0))
folder.addParmTemplate(hou.ToggleParmTemplate("iskinematic", "Is Kinematic", 1))
folder.addParmTemplate(hou.ToggleParmTemplate("istrigger", "Is Trigger", 0))
folder.addParmTemplate(hou.FloatParmTemplate("gravityoverride", "Gravity Override",3))
group.append(folder)
n.setParmTemplateGroup(group)
def _create_toggle_parm(take):
"""Generate a toggle widget for a take tup(takename, depth).
Note, the takes tag is false, because of course you
can't have a different set of takes active for each
take.
"""
take_name, depth = take
name = _to_parm_name(take_name)
indent = ("- " * depth)
label = "%s%s" % (indent, take_name)
tags = {
"script_callback": "hou.pwd().hdaModule().takes(**kwargs)",
"script_callback_language": "python",
"takes": "False"
}
return hou.ToggleParmTemplate(name, label, tags=tags)
def _build_single_file_parm(self, default):
"""
Build a template for the single file parm.
:param bool default: The default check state of the parm.
:returns: A :class:`hou.ToggleParmTemplate` instance.
"""
sgtk_single_frame = hou.ToggleParmTemplate(
self.SGTK_SINGLE_FRAME,
"Single File",
default_value=default,
script_callback=self.generate_callback_script_str(
"refresh_file_path"),
script_callback_language=hou.scriptLanguage.Python,
)
sgtk_single_frame.setConditional(hou.parmCondType.DisableWhen,
"{ use_sgtk != 1 }")
return sgtk_single_frame
def create_displacement_parms(self, node):
"""
Create Shaders folder if it doesnt exist and create shop_disable_displace_shader
parm inside it.
"""
# add_folder 'Shaders'
self.add_folder(node, 'Shaders')
#Create Parameters
#------------------------------------------------------------------
# parm_template_group
parm_template_group = node.parmTemplateGroup()
# folder_shaders
folder_shaders = parm_template_group.findFolder('Shaders')
# shop_disable_displace_shader
hou_parm_template = hou.ToggleParmTemplate("shop_disable_displace_shader", "Disable Displace Shader Rendering", default_value=False)
hou_parm_template.setHelp("None")
hou_parm_template.setTags({"spare_category": "Shaders"})
#append
parm_template_group.appendToFolder(folder_shaders, hou_parm_template)
#set in node
node.setParmTemplateGroup(parm_template_group)
#log
parm = node.parm("shop_disable_displace_shader")
parm_name = parm.name()
parm_value = parm.eval()
print('Added parm. {0} - {1}'.format(parm_name, parm_value))
#Adjust Parameters
#------------------------------------------------------------------
# shop_disable_displace_shader
hou_parm = node.parm("shop_disable_displace_shader")
hou_parm.lock(False)
hou_parm.set(0)
hou_parm.setAutoscope(False)
def add_operator_id_render_property(self, node):
"""
Add vm_generate_opid property to mantra node. This property ensures that
the render_id passes work.
"""
#Create Parameters
#------------------------------------------------------------------
#parm_group
parm_group = node.parmTemplateGroup()
#folder_output
folder_output = parm_group.containingFolder('vm_picture')
#vm_decoupleindirect
hou_parm_template = hou.ToggleParmTemplate("vm_generate_opid",
"Generate Operator IDs",
default_value=True)
hou_parm_template.setHelp("None")
hou_parm_template.setTags({"spare_category": "Output"})
#append
parm_group.appendToFolder(folder_output, hou_parm_template)
#set in node
node.setParmTemplateGroup(parm_group)
#log
parm = node.parm("vm_generate_opid")
parm_name = parm.name()
parm_value = parm.eval()
print('Added parm. {0} - {1}'.format(parm_name, parm_value))
#Adjust Parameters
#------------------------------------------------------------------
#vm_generate_opid
hou_parm = node.parm("vm_generate_opid")
hou_parm.lock(False)
hou_parm.setAutoscope(False)
def _create_sgtk_folder(self, node, use_sgtk_default=True, hou=None):
"""
Create the sgtk folder template.
This contains the common parameters used by all node handlers.
:param node: A :class:`hou.Node` instance.
:param bool use_sgtk_default: Whether the "Use Shotgun" checkbox is to be
checked by default.
:param hou: The houdini module. We have to lazy load the houdini python
module here, but not in the hooks, so use hook's imports and pass it
for efficiency.
"""
if not hou:
import hou
sgtk_templates = []
use_sgtk = hou.ToggleParmTemplate(
self.USE_SGTK,
"Use Shotgun",
default_value=use_sgtk_default,
script_callback=self.generate_callback_script_str("enable_sgtk"),
script_callback_language=hou.scriptLanguage.Python,
)
sgtk_templates.append(use_sgtk)
sgtk_templates.extend(self._create_sgtk_parm_fields(node, hou))
engine_version = (self.parent.version
if self.parent.version != "Undefined" else "DEV")
sgtk_folder = hou.FolderParmTemplate(
self.SGTK_FOLDER,
"SGTK (ver: {})".format(engine_version),
parm_templates=sgtk_templates,
folder_type=hou.folderType.Simple,
)
return sgtk_folder
def _set_up_node(self, node, parameter_group, hou=None):
"""
Set up a node for use with shotgun pipeline.
:param node: A :class:`hou.Node` instance.
:param parameter_group: A :class:`ParmGroup` instance.
:param hou: The houdini module. We have to lazy load the houdini python
module here, but not in the hooks, so use hook's imports and pass it
for efficiency.
"""
if not hou:
import hou
self._set_up_parms(node)
sgtk_folder = self._create_sgtk_folder(node)
sgtk_identifier = hou.ToggleParmTemplate(self.SGTK_IDENTIFIER,
"SGTK",
default_value=True,
is_hidden=True)
parameter_group.append_template(sgtk_identifier)
self._customise_parameter_group(node, parameter_group, sgtk_folder)
node.setParmTemplateGroup(parameter_group.build())
self._set_up_init_node_values(node)
def c_light(n):
group = n.parmTemplateGroup()
folder = hou.FolderParmTemplate("folder", "Static Model Component")
folder.addParmTemplate(hou.MenuParmTemplate("lighttype", "Light Type",("Directional","Spot","Point",),default_value=2))
folder.addParmTemplate(hou.FloatParmTemplate("color", "Color",4,(1.0,1.0,1.0,1.0,)))
folder.addParmTemplate(hou.FloatParmTemplate("specintensity", "Spec Intensity", 1, (1.0,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("brightmult", "Brightness Multiplier", 1, (1.0,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("range", "Range", 1, (10.0,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("spotfov", "Spot FOV", 1, (30.0,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("spotaspectratio", "Spot Aspect Ratio", 1, (1.0,) ) )
folder.addParmTemplate(hou.StringParmTemplate("atttext", "Attenuation Texture", 1))
folder.addParmTemplate(hou.StringParmTemplate("lightshapetext", "Light Shape Texture",1))
folder.addParmTemplate(hou.ToggleParmTemplate("isoccludable", "Can Be Occluded", 1))
folder.addParmTemplate(hou.ToggleParmTemplate("castshadows", "Cast Shadows", 0))
folder.addParmTemplate(hou.ToggleParmTemplate("prevertex", "Per Vertex", 0))
folder.addParmTemplate(hou.FloatParmTemplate("drawdistance", "Draw Distance", 1 ) )
folder.addParmTemplate(hou.FloatParmTemplate("fadedistance", "Fade Distance", 1 ) )
folder.addParmTemplate(hou.FloatParmTemplate("shadowdistance", "Shadow Distance", 1 ) )
folder.addParmTemplate(hou.FloatParmTemplate("shadowfadedistance", "Shadow Fade Distance", 1 ) )
folder.addParmTemplate(hou.FloatParmTemplate("shadowintensity", "Shadow Intensity", 1 ) )
folder.addParmTemplate(hou.FloatParmTemplate("shadowresolution", "Shadow Resolution", 1 ) )
folder.addParmTemplate(hou.ToggleParmTemplate("focustoscene", "Focus To Scene", 1))
folder.addParmTemplate(hou.ToggleParmTemplate("nonuniformview", "Non Uniform View", 1))
folder.addParmTemplate(hou.ToggleParmTemplate("autoreducesize", "Auto Reduce Size", 1))
folder.addParmTemplate(hou.FloatParmTemplate("cmssplits", "CMS Splits",3,(1000.0,0.0,0.0,)))
folder.addParmTemplate(hou.FloatParmTemplate("cmsfadestart", "CMS Fade Start", 1, (0,8,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("cmsbiasautoadjust", "CMS Bias Auto Adjust", 1, (1.0,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("viewsizequantize", "View Size Quantize", 1, (0.5,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("viewsizemin", "View Size Minimum", 1, (1.0,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("depthconstantbias", "Depth Constant Bias", 1, (0.0002,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("depthslopebias", "Depth Slope Bias", 1, (0.5,) ) )
folder.addParmTemplate(hou.FloatParmTemplate("nearfarclip", "Near Far Clip Ratio", 1, (0.002,) ) )
folder.addParmTemplate(hou.IntParmTemplate("viewmask", "View Mask",1,(-1,)))
folder.addParmTemplate(hou.IntParmTemplate("lightmask", "Light Mask",1,(-1,)))
group.append(folder)
n.setParmTemplateGroup(group)
def update_rop_output_paths_for_selected_nodes(self, kwargs={}):
print "Update Rop Output Paths for Selected SOP/TOP Nodes. Note: currently not handling @attributes $attributes in element names correctly."
self.selected_nodes = kwargs['items']
for node in self.selected_nodes:
print 'Name', node.name()
if node.type().name() == 'ropfetch':
node = node.node(node.parm('roppath').eval())
if node:
print 'set path', node.path()
#hou.hscriptExpression("cd "+node.path())
hou.cd(node.path())
bake_names = True
print "evaluate env vars"
if bake_names:
node_name = node.name()
show_var = hou.hscriptExpression("${SHOW}")
seq_var = hou.hscriptExpression("${SEQ}")
shot_var = hou.hscriptExpression("${SHOT}")
shot_var = show_var + '.' + seq_var + '.' + shot_var
shotpath_var = hou.hscriptExpression("${SHOTPATH}")
scene_name = hou.hscriptExpression("${SCENENAME}")
else:
node_name = "${OS}"
show_var = "${SHOW}"
seq_var = "${SEQ}"
shot_var = "${SHOT}"
shot_var = "${SHOW}.${SEQ}.${SHOT}"
shotpath_var = "${SHOTPATH}"
scene_name = "${SCENENAME}"
print shot_var
scene_name_default = scene_name
shot_default = shot_var
file_template_default = "`chs('shot_path')`/`chs('output_type')`/`chs('element_name')`/`chs('versionstr')`/`chs('shot')`.`chs('scene_name')`.`chs('element_name')`.`chs('versionstr')`.`chs('wedge_string')`.`chs('frame')`.`chs('file_type')`"
# If target matches node typ in dict, then apply versioning
print 'node type', node.type().name()
if node.type().name() in self.output_types:
lookup = self.output_types[node.type().name()]
extension = lookup['extension']
print 'extension', extension
static_expression = lookup['static_expression']
out_parm_name = lookup['output']
# check if overide for default
file_template = file_template_default
if 'file_template' in lookup:
print "overiding file tempalte"
file_template = lookup['file_template']
print "file_template", file_template
try:
parm_group = node.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate(
"folder", "Versioning")
callback_expr = \
"""
# This allows versioning to be inherited by the multi parm db
import hou
node = hou.pwd()
parm = hou.evaluatingParm()
print 'parm callback', parm.name()
"""
parm_folder.setScriptCallbackLanguage(
hou.scriptLanguage.Python)
parm_folder.setScriptCallback(callback_expr)
#parm_folder.addParmTemplate(hou.StringParmTemplate("element_name_template", "Element Name Template", 1, ["${OS}"]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("element_name_template",
"Element Name Template", 1,
["${OS}"]))
element_name_parm = hou.StringParmTemplate(
"element_name", "Element Name", 1, [node_name])
#elementName.setScriptCallback(callback_expr)
#elementName.setScriptCallbackLanguage(hou.scriptLanguage.Python)
parm_folder.addParmTemplate(element_name_parm)
parm_folder.addParmTemplate(
hou.ToggleParmTemplate(
"auto_version",
"Auto Version Set To Hip Version on Execute",
1))
parm_folder.addParmTemplate(
hou.IntParmTemplate("version_int", "Version", 1))
parm_folder.addParmTemplate(
hou.StringParmTemplate("versionstr",
"Version String", 1, [""]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("wedge_string",
"Wedge String", 1,
["w`@wedgenum`"]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("output_type",
"Output Type", 1,
[lookup['type_path']]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("shot", "Shot", 1,
[shot_default]))
parm_folder.addParmTemplate(
hou.MenuParmTemplate(
'location',
'Location',
("submission_location", "cloud", "onsite"),
("Submission Location", "Cloud", "Onsite"),
default_value=0))
# parm_folder.addParmTemplate(hou.MenuParmTemplate("location", "Location", menu_items=(["submission_location","cloud","onsite"]), menu_labels=(["Submission Location","Cloud","Onsite"]), default_value=0, icon_names=([]), item_generator_script="", item_generator_script_language=hou.scriptLanguage.Python, menu_type=hou.menuType.Normal, menu_use_token=False, is_button_strip=False, strip_uses_icons=False)
parm_folder.addParmTemplate(
hou.StringParmTemplate("shot_path_template",
"Shot Path Template", 1,
["${SHOTPATH}"]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("shot_path", "Shot Path", 1,
[shotpath_var]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("scene_name", "Scene Name",
1, [scene_name_default]))
# default_expression=("hou.frame()"), default_expression_language=(hou.scriptLanguage.Python) ) )
parm_folder.addParmTemplate(
hou.StringParmTemplate("frame", "Frame", 1,
["$F4"]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("file_type", "File Type", 1,
[extension]))
parm_folder.addParmTemplate(
hou.StringParmTemplate("file_template",
"File Template", 1,
[file_template]))
#parm_folder.addParmTemplate(hou.FloatParmTemplate("amp", "Amp", 2))
parm_group.append(parm_folder)
node.setParmTemplateGroup(parm_group)
hou_parm = node.parm("versionstr")
hou_parm.lock(False)
hou_parm.setAutoscope(False)
hou_keyframe = hou.StringKeyframe()
hou_keyframe.setTime(0)
ver_expr = \
"""
# This allows versioning to be inherited by the multi parm db
import hou
import re
node = hou.pwd()
parm = hou.evaluatingParm()
index_key = node.parm('index_key_template').eval()
multiparm_index = node.userData('verdb_'+index_key)
version = 0
if multiparm_index is not None:
multiparm_index = str(multiparm_index)
version_parm = node.parm('version'+multiparm_index)
if version_parm is not None:
version = version_parm.eval()
return version
"""
hou_keyframe.setExpression(ver_expr,
hou.exprLanguage.Python)
hou_parm.setKeyframe(hou_keyframe)
expr = \
"""
import hou
node = hou.pwd()
lookup = {'submission_location':'$PROD_ROOT', 'cloud':'$PROD_CLOUD_ROOT', 'onsite':'$PROD_ONSITE_ROOT'}
location = node.parm('location').evalAsString()
root = lookup[location]
template = root+'/$SHOW/$SEQ/$SHOT'
return template
"""
hou_parm = node.parm("shot_path_template")
hou_parm.lock(False)
hou_parm.setAutoscope(False)
hou_keyframe = hou.StringKeyframe()
hou_keyframe.setTime(0)
hou_keyframe.setExpression(expr,
hou.exprLanguage.Python)
hou_parm.setKeyframe(hou_keyframe)
parms_added = True
except:
parms_added = False
if static_expression:
hou_parm = node.parm("frame")
hou_parm.lock(False)
hou_parm.setAutoscope(False)
hou_keyframe = hou.StringKeyframe()
hou_keyframe.setTime(0)
if 'overrides' in lookup and 'frame' in lookup[
'overrides']:
print 'has override for static_expression'
hou_keyframe.setExpression(
lookup['overrides']['frame'],
hou.exprLanguage.Python)
else:
hou_keyframe.setExpression(
"import hou" + '\n' + "node = hou.pwd()" +
'\n' + "step = node.parm('f3').eval()" + '\n' +
"if node.parm('trange').evalAsString() == 'off':"
+ '\n' + " value = 'static'" + '\n' +
"elif step != 1:" + '\n' +
" value = '$FF'" + '\n' + "else:" + '\n' +
" value = '$F4'" + '\n' + "return value",
hou.exprLanguage.Python)
# if node.parm('framegeneration').evalAsString() == '0':
hou_parm.setKeyframe(hou_keyframe)
# set defaults here if parms already exist and changes are made
node.parm("scene_name").set(scene_name_default)
node.parm("shot").set(shot_default)
element_name_template = node.parm(
"element_name_template").evalAsString()
try:
shot_path_template = hou.expandString(
node.parm("shot_path_template").evalAsString())
#element_name_template = node.parm("element_name_template").evalAsString()
except:
shot_path_template = shotpath_var
node.parm('element_name').set(element_name_template)
node.parm("shot_path").set(shot_path_template)
node.parm('file_template').set(file_template)
bake_template = False
replace_env_vars_for_tops = True
auto_version = node.parm("auto_version").eval()
print 'auto_version', auto_version
# if autoversion tickbox enabled, then update version to hip version on execute of tool.
if node.parm("auto_version").eval():
set_version = int(
hou.hscriptExpression('opdigits($VER)'))
print 'set version', set_version
node.parm("version_int").set(set_version)
if bake_template:
file_path_split = node.parm(
'file_template').unexpandedString()
file_path_split = file_path_split.replace(
"`chs('frame')`", "{{ frame }}")
file_path_split = file_path_split.replace(
"`chs('versionstr')`", "{{ versionstr }}")
file_path_split = file_path_split.replace(
"`chs('wedge_string')`", "{{ wedge_string }}")
file_path_split = file_path_split.replace(
"`chs('element_name')`", "{{ element_name }}")
# expand any values that we do not wish to be dynamic.
file_path = hou.expandString(file_path_split)
try:
file_path = file_path.replace(
"{{ frame }}",
node.parm('frame').unexpandedString())
except:
file_path = file_path.replace(
"{{ frame }}",
node.parm('frame').eval())
file_path = file_path.replace("{{ versionstr }}",
"`chs('versionstr')`")
file_path = file_path.replace("{{ wedge_string }}",
"`chs('wedge_string')`")
file_path = file_path.replace("{{ element_name }}",
"`chs('element_name')`")
# overide, and use template
else:
file_path_split = node.parm(
'file_template').unexpandedString()
file_path_split = file_path_split.replace(
"`chs('frame')`", "{{ frame }}")
file_path_split = file_path_split.replace(
"`chs('element_name')`", "{{ element_name }}")
file_path = file_path_split
try:
file_path = file_path.replace(
"{{ frame }}",
node.parm('frame').unexpandedString())
except:
file_path = file_path.replace(
"{{ frame }}",
node.parm('frame').eval())
element_name = node.parm(
'element_name').unexpandedString()
if replace_env_vars_for_tops:
print 'replace environment vars in element name with @ lower case version attributes'
env_var_matches = re.findall(
r'\$\{.*?\}', element_name)
print 'element_name', element_name
print 'env_var_matches', env_var_matches
ignore = ['${OS}']
for match in env_var_matches:
if match not in ignore:
replacement = match.strip('${}').lower()
element_name = element_name.replace(
match, '`@' + replacement + '`')
else:
print 'will preserve environment vars in element name'
# we bake the element name into the path so that copy of a node will not break refs in the event of a duplicate node existing in the target network to copy to.
# element name cannot be ${OS} because if it changes the reader will not function from the template parms schema.
file_path = file_path.replace("{{ element_name }}",
element_name)
# We bake the full definition of the cached output string into the output file string, except for the frame variable, version and wedge which remains as hscript/chanel refs.
# this provides a safe means for copying cache nodes into other scenes without breaking references.
# references should be updated on write via a prerender script executing this function to ensure $VER is updated to a current value.
print 'out path', file_path
node.parm(out_parm_name).set(file_path)
print "add defs"
def update_index(node, index_int):
index_key_parm_name = 'index_key' + str(index_int)
#print "update node", node, 'index_int', index_int, 'index_key_parm_name', index_key_parm_name
index_key_parm = node.parm(index_key_parm_name)
#print 'update index from parm', index_key_parm
index_key = index_key_parm.eval()
#version = node.parm('version' + str(index_int) ).eval()
node.setUserData('verdb_' + index_key, str(index_int))
#print "Changed parm index_key", index_key, "index_int", index_int
# ensure parameter callbacks exists
def parm_changed(node, event_type, **kwargs):
print "parm changed"
parm_tuple = kwargs['parm_tuple']
if parm_tuple is None:
parm_warn = int(
hou.node("/obj").cachedUserData(
"parm_warn_disable") != '1')
if parm_warn:
hou.ui.displayMessage(
"Too many parms were changed. callback hasn't been designed to handle this yet, changes may be needed in cloud_submit.py to handle this. see shell output"
)
print "Too many parms were changed. callback hasn't been designed to handle this yet, changes may be needed in cloud_submit.py to handle this. see shell output. This warning will be displayed once for the current session."
hou.node("/obj").setCachedUserData(
'parm_warn_disable', '1')
print "node", node
print "event_type", event_type
print "parm_tuple", parm_tuple
print "kwargs", kwargs
else:
name = parm_tuple.name()
# if a key has changed
is_multiparm = parm_tuple.isMultiParmInstance()
if is_multiparm and 'index_key' in name:
if len(parm_tuple.eval()) > 1:
hou.ui.displayMessage(
"multiple items in tuple, changes may be needed in cloud_submit.py to handle this"
)
index_int = next(re.finditer(r'\d+$',
name)).group(0)
print 'index_key in name', name, 'update', index_int
update_index(node, index_int)
# if multiparm instance count has changed, update all and remove any missing.
if 'versiondb0' in name:
multiparm_count = parm_tuple.eval()[0]
print "Total parms changed. validate and clean out old dict. total parms:", multiparm_count
index_keys = []
for index_int in range(
1,
int(multiparm_count) + 1):
index_key_parm_name = 'index_key' + \
str(index_int)
index_key_parm = node.parm(
index_key_parm_name)
print 'update', index_key_parm.name()
index_key = index_key_parm.eval()
index_keys.append('verdb_' + index_key)
print 'update index', index_int, 'node', node
update_index(node, index_int)
# first all items in dict will be checked for existance on node. if they dont exist they will be destroyed on the dict.
user_data_total = 0
keys_to_destroy = []
for index_key, value in node.userDataDict(
).items():
if index_key not in index_keys and 'verdb_' in index_key:
print "node missing key", index_key, ":", value, 'will remove'
keys_to_destroy.append(index_key)
else:
user_data_total += 1
if len(keys_to_destroy) > 0:
for index_key in keys_to_destroy:
node.destroyUserData(index_key)
print "destroyed key", index_key
# all lookups and validation needs to double check the data is correct. if incorrect, trigger cleanup.
# if number of entries dont match, trigger cleanup. this can occur if a wedge is entered in as an index manually, and then altered. we locked parms to avoid this.
# new indexes should be automated.
# remove callback to replace
#removeEventCallback((hou.nodeEventType.ParmTupleChanged, ), parm_changed)
print "add callback"
node.addEventCallback(
(hou.nodeEventType.ParmTupleChanged, ), parm_changed)
def createReferencePlane(self, width, height, path):
"""Create reference plane object from a given file sequence and orient it to a current view.
INPUTS:
width -- image width
height -- image height
path -- given file sequence path string
"""
with hou.undos.group("Create Reference Plane"):
viewer = toolutils.sceneViewer()
a = viewer.curViewport().viewTransform().extractRotates()
b = viewer.curViewport().viewTransform().extractTranslates()
temp_null = hou.node('obj/').createNode('null', 'IB_Temp_Null')
temp_null.setParms({
'tx': b[0],
'ty': b[1],
'tz': b[2],
'rx': a[0],
'ry': a[1],
'rz': a[2]
})
geo = hou.node('obj/').createNode('geo', 'IB_Reference_Plane')
geo_parm_group = geo.parmTemplateGroup()
geo_parm_folder = hou.FolderParmTemplate("folder", "Controls")
geo_parm_folder.addParmTemplate(
hou.IntParmTemplate("frame_offset",
"Frame Offset",
1,
min=-100,
max=100))
geo_parm_group.append(geo_parm_folder)
geo.setParmTemplateGroup(geo_parm_group)
ref = geo.createNode('shopnet', 'Reference_Sequence')
ref.moveToGoodPosition()
ref_mat = ref.createNode('vopmaterial', 'Reference_Mat')
parm_group = ref_mat.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate("folder", "OpenGL")
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_diff", "Diffuse", 3))
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_emit", "Emission", 3))
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_emit_intensity",
"Emission Intensity", 1))
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_rough", "Roughness", 1))
parm_folder.addParmTemplate(
hou.ToggleParmTemplate("ogl_use_emit", "Enable Emission"))
parm_folder.addParmTemplate(
hou.ToggleParmTemplate("ogl_use_emissionmap",
"Use Emission Map"))
parm_folder.addParmTemplate(
hou.StringParmTemplate("ogl_emissionmap", "Emission Map", 1))
parm_group.append(parm_folder)
ref_mat.setParmTemplateGroup(parm_group)
ref_mat.setParms({
"ogl_diffx": 0,
"ogl_diffy": 0,
"ogl_diffz": 0,
"ogl_emitx": 1,
"ogl_emity": 1,
"ogl_emitz": 1,
"ogl_emit_intensity": 1,
"ogl_rough": 0,
"ogl_use_emit": 1,
"ogl_use_emissionmap": 1,
"ogl_emissionmap": path
})
grid = geo.createNode('grid')
grid.setParms({
'orient': 0,
'sizex': float(width) / 100,
'sizey': float(height) / 100,
'rows': 2,
'cols': 2
})
uv_set = geo.createNode('uvproject')
uv_set.setInput(0, grid)
uv_set.parm('inittype').set(0)
uv_set.parm('initbbox').pressButton()
mat = geo.createNode('material')
mat.setInput(0, uv_set)
mat.parm('shop_materialpath1').set(
'../Reference_Sequence/Reference_Mat')
mat.setDisplayFlag(1)
mat.setRenderFlag(1)
geo.layoutChildren()
geo.setInput(0, temp_null)
geo.parm('tz').set(-50)
geo.parm('keeppos').set(1)
geo.setInput(0, None)
temp_null.destroy()
for curr_node in node.parent().children():
if curr_node != node and curr_node != file_node:
DA_nodes.append(curr_node)
subnet = node.parent().collapseIntoSubnet(tuple(DA_nodes))
subnet.setName("mesh_repairer")
if subnet.canCreateDigitalAsset():
asset = subnet.createDigitalAsset(
name="Mesh_Repairer_Oz",
min_num_inputs = 1,
max_num_inputs = 1,
ignore_external_references = True)
parm_group = asset.parmTemplateGroup()
# Input Folder
inputs_folder = hou.FolderParmTemplate("inputs_folder", "Inputs", folder_type=hou.folderType.Tabs)
inputs_folder.addParmTemplate(hou.ToggleParmTemplate("isPath", "Use Unique Path", 0, help="Check to change path to look for session file", script_callback='if not bool(hou.pwd().parm("isPath").eval()): hou.pwd().parm("repairPath").set("Using path to HIP")', script_callback_language = hou.scriptLanguage.Python))
inputs_repair_path = hou.StringParmTemplate("repairPath", "Repairer Path", 1, default_value=("Using path to HIP",), help="Path to Mesh Repairer")
inputs_repair_path.setConditional(hou.parmCondType.DisableWhen, "{ isPath == 0 }")
inputs_folder.addParmTemplate(inputs_repair_path)
input_control = 'repair_path = hou.pwd().parm("repairPath").eval() if bool(hou.pwd().parm("isPath").eval()) else hou.getenv("HIP");\
hou.appendSessionModuleSource(open(repair_path + "/session.py", "r").read() if not "# -- Houdini Mesh Repairer -- #" in hou.sessionModuleSource() else "")'
inputs_folder.addParmTemplate(hou.ButtonParmTemplate("inputs_init", "Initialize Repairer Session",
script_callback = input_control, script_callback_language = hou.scriptLanguage.Python, help="Initialize Houdini session using Repairer Path"))
inputs_folder.addParmTemplate(hou.ToggleParmTemplate("isSmooth", "Smooth Boundaries", 0,
script_callback='hou.node(hou.pwd().path() + "/smooth_boundaries/smooth").parm("strength").set(int(hou.pwd().parm("inputs_smooth_factor").eval()) * int(hou.pwd().parm("isSmooth").eval()))',
script_callback_language=hou.scriptLanguage.Python, help="Smooth input hole boundaries"))
inputs_smooth_factor = hou.IntParmTemplate("inputs_smooth_factor", "Smooth Boundaries Factor",
1, default_value=(50,), min=0, max=100,
min_is_strict=True, max_is_strict=False,
script_callback='hou.node(hou.pwd().path() + "/smooth_boundaries/smooth").parm("strength").set(int(hou.pwd().parm("inputs_smooth_factor").eval()) * int(hou.pwd().parm("isSmooth").eval()))',
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 initRopNotificationProperty(node):
"""Given a ROP node, replaces the execute button with an identical
button that launches a notification after the cache/render process
if the newly added checkbox is checked.
Args:
node (hou.Node): The ROP node to add the new button and notifications
checkbox to
"""
parmTemplate = node.parmTemplateGroup()
notifyParm = hou.ToggleParmTemplate(
'notify',
'Notify on Completion',
help=
'Receive a notification when this ROP output operation completes. Notifications are based on settings in SDMTools > Preferences.'
)
notifyScript = "; from sdm.houdini.notifications import notifyUser, NotificationType;" \
"seconds = time.time() - start;" \
"m, s = divmod(seconds, 60);" \
"h, m = divmod(m, 60);" \
"p = hou.pwd().parm('notify');" \
"data = {'Node':hou.pwd().name(), 'Duration':'%d:%02d:%02d' % (h, m, s)};" \
"notifyUser(NotificationType.ROP_COMPLETE if p and p.eval() else None, data=data)"
if node.type() == 'filecache':
folderParm = parmTemplate.containingFolder('execute')
allParms = folderParm.parmTemplates()
newParms = ()
for parm in allParms:
if parm.name() == 'renderdialog':
parm.setJoinWithNext(True)
newParms += (parm, )
newParms += (notifyParm, )
elif parm.name() == 'execute':
execCache = parm.clone()
parm.hide(True)
newParms += (parm, )
callback = execCache.scriptCallback()
callback = 'import time; start = time.time(); ' + callback
callback += notifyScript
execCache.setScriptCallback(callback)
execCache.setName('executeWithNotification')
newParms += (execCache, )
else:
newParms += (parm, )
folderParm.setParmTemplates(newParms)
parmTemplate.replace(folderParm.name(), folderParm)
else:
renderButton = parmTemplate.find('execute')
if renderButton:
renderNotify = renderButton.clone()
renderButton.hide(True)
callback = renderButton.scriptCallback(
) or 'import hou; hou.pwd().render()'
callback = 'import time; start = time.time(); ' + callback
callback += notifyScript
renderNotify.setScriptCallback(callback)
renderNotify.setName('executeWithNotification')
parmTemplate.replace('execute', renderButton)
parmTemplate.insertAfter('execute', renderNotify)
parmTemplate.insertAfter('renderdialog', notifyParm)
node.setParmTemplateGroup(parmTemplate)
def add_renderman_settings(geo, archiveName, ribArchDir, pxrdisplace=None, pxrdisplaceexpr=None, riboundExpr=None, add_displacement=False):
# Get the paramter template group from the current geo node
hou_parm_template_group = geo.parmTemplateGroup()
# Create a folder for the RenderMan parameters
renderman_folder = hou.FolderParmTemplate('renderman', 'RenderMan', folder_type=hou.folderType.Tabs, default_value=0, ends_tab_group=False)
# Create a new parameter for RenderMan 'Interpolate Boundary'
interpolate_boundary = hou.ToggleParmTemplate('ri_interpolateboundary', 'Interpolate Boundary', default_value=False)
interpolate_boundary.setHelp('RiSubdivisionMesh - interpolateboundary')
interpolate_boundary.setTags({'spare_category': 'Geometry'})
renderman_folder.addParmTemplate(interpolate_boundary)
# Create a new parameter for Render Man 'Render as Subdivision' option
rendersubd = hou.ToggleParmTemplate('ri_rendersubd', 'Polygons as Subdivision (RIB)', default_value=False)
rendersubd.setHelp('RiSubdivisionMesh')
rendersubd.setTags({'spare_category': 'Geometry'})
renderman_folder.addParmTemplate(rendersubd)
#create displacement bound
render_displacement_bound = hou.properties.parmTemplate(get_latest_prman(),"ri_dbound")
renderman_folder.addParmTemplate(render_displacement_bound)
#add archive file
archive = hou.properties.parmTemplate(get_latest_prman(),"ri_archive")
ribArchExpr = 'ifs(ch("../source_index") == 0,'
ribArchExpr += '"$JOB/production/assets/" + chs("../set") + "/rib_archive/main/cache/' + archiveName + '" + ifs(ch("../abcversion"), ch("../abcversion"), "") + ".rib",'
ribArchExpr += 'ifs(ch("../source_index") == 1,'
ribArchExpr += '"$JOB/production/shots/" + chs("../shot") + "/rib_archive/main/cache/' + archiveName + '" + ifs(ch("../abcversion"), ch("../abcversion"), "") + "_$F4.rib",'
ribArchExpr += '"' + ribArchDir + '/' + archiveName + '.rib"))'
archive.setDefaultExpression((ribArchExpr,))
renderman_folder.addParmTemplate(archive)
#add auto-archive config
auto_archive = hou.properties.parmTemplate(get_latest_prman(),"ri_auto_archive")
auto_archive.setDefaultExpression(('chs("../ri_auto_archive")',))
renderman_folder.addParmTemplate(auto_archive)
# TODO: If we can get the displacement to work by group then we don't need to have this here anymore. We will need to finish hooking it up in addMaterialOptions()
if(add_displacement):
# Create a new parameter for RenderMan 'Displacement Shader'
displacement_shader = hou.StringParmTemplate('shop_displacepath', 'Displacement Shader', 1, default_value=(['']), naming_scheme=hou.parmNamingScheme.Base1, string_type=hou.stringParmType.NodeReference, menu_items=([]), menu_labels=([]), icon_names=([]), item_generator_script='', item_generator_script_language=hou.scriptLanguage.Python, menu_type=hou.menuType.Normal)
displacement_shader.setHelp('RiDisplace')
displacement_shader.setTags({'oprelative': '.','spare_category': 'Shading'})
renderman_folder.addParmTemplate(displacement_shader)
# Create a new parameter for RenderMan 'Displacement Bound'
displacement_bound = hou.properties.parmTemplate(get_latest_prman(),"ri_dbound")
renderman_folder.addParmTemplate(displacement_bound)
hou_parm_template_group.append(renderman_folder)
geo.setParmTemplateGroup(hou_parm_template_group)
# TODO: If we can get the displacement to work by group then we don't need to have this here anymore. We will need to finish hooking it up in addMaterialOptions()
if add_displacement:
# Code for /obj/geo1/shop_displacepath parm
hou_parm = geo.parm('shop_displacepath')
hou_parm.lock(False)
if pxrdisplace is not None:
hou_parm.set(pxrdisplace.relativePathTo(geo))
if pxrdisplaceexpr is not None:
hou_parm.setExpression(pxrdisplaceexpr)
hou_parm.setAutoscope(False)
# Code for ri_dbound parm
hou_parm = geo.parm('ri_dbound')
hou_parm.lock(False)
hou_parm.set(0)
if riboundExpr is not None:
hou_parm.setExpression(riboundExpr)
hou_parm.setAutoscope(False)
# Code for ri_interpolateboundary parm
hou_parm = geo.parm('ri_interpolateboundary')
hou_parm.lock(False)
hou_parm.set(1)
hou_parm.setAutoscope(False)
# Code for ri_rendersubd parm
hou_parm = geo.parm('ri_rendersubd')
hou_parm.lock(False)
hou_parm.set(1)
hou_parm.setAutoscope(False)
return geo
def assemble_set(project, environment, assembly, asset, checkout_file):
set_hda = create_hda(asset, assembly, project, environment, checkout_file)
print 'This is a set'
print('----------')
model = asset.get_element(Department.MODEL)
# Get all of the static geo
model_cache = model.get_cache_dir()
model_cache = model_cache.replace(project.get_project_dir(), '$JOB')
geo_files = [x for x in os.listdir(model.get_cache_dir()) if not os.path.isdir(x)]
geo_files = clean_file_list(geo_files, '.abc')
# Set up the set parameters
# Create a folder for the set parameters
set_folder = hou.FolderParmTemplate('set_options', 'Set Options', folder_type=hou.folderType.Tabs, default_value=0, ends_tab_group=False)
auto_archive = hou.properties.parmTemplate(get_latest_prman(),"ri_auto_archive")
auto_archive.setDefaultValue(("exist",))
set_folder.addParmTemplate(auto_archive)
set_folder.addParmTemplate(create_set_menu(hidden=True, value=asset.get_name()))
set_folder.addParmTemplate(create_shot_menu())
used_hdas = set()
for geo_file in geo_files:
geo_file_path = os.path.join(model_cache, geo_file)
name = ''.join(geo_file.split('.')[:-1])
#print 'The name of the alembic file is ', name
# find the alembic version
elementName = '_main'
index = name.find(elementName)
versionNum = name[index + len(elementName):]
#print 'This is the versionNum ', versionNum
# TODO : what if it is a rig? I am begninng to wonder if maybe it will always be the model becuase in the rig file it is referencing the model.
index = name.find('_model')
if(index < 0):
index = name.find('_rig')
if(index < 0):
print 'We couldn\'t find either a rig or a model for this asset. That means something went wrong or I need to rethink this tool.'
asset_name = name[:index]
#check if HDA is set to prevent nested set HDAS
project=Project()
body = project.get_body(asset_name)
print asset_name
if body is not None:
if body.get_type() == AssetType.SET:
continue
else:
print ('No body exists for: ' + asset_name)
continue
#print asset_name
asset_version = str(asset_name) + str(versionNum)
if(asset_version in used_hdas):
print used_hdas
print 'But I think is okay if it is in used_hdas because we have decided that it\'s cool to have multibples'
#TODO get rid of used_hdas if we don't need it anymore now that we are allowing duplication of assets
continue
try:
hda = set_hda.createNode(asset_name + '_main')
except:
message_gui.error('There is no asset named ' + str(asset_name) + '. You may need to assemble it first.')
hda.destroy()
return
used_hdas.add(asset_version)
# set the alembic version number
if versionNum != '':
try:
#print 'This is versionNum before the change ', versionNum
versionNum = int(versionNum)
#print 'This is versionNum after the change ', versionNum
hda.parm('abcversion').set(int(versionNum))
except Exception as err:
errorMessage = 'There was an error assigning the version number. It may be because the asset needs to be reassembled. Check that the ' + str(asset_name) + ' node has the version slider. If not reassemble it and try again.\n'
message_gui.error(errorMessage, details=str(err))
#finish the rest of the setup
label_text = asset_version.replace('_', ' ').title()
# Using the column label instead of the regular label lets us put longer names without them getting truncated. The problem is that its not left justified like I would want but its going to have to do for now. It is really quite a bit less than ideal but it will still comunicate the needed info so here we go.
columnLabel = (label_text,)
#print columnLabel
geo_label = hou.LabelParmTemplate(asset_version, '', column_labels=columnLabel)
hide_toggle_name = 'hide_' + asset_version
hide_toggle = hou.ToggleParmTemplate(hide_toggle_name, 'Hide')
animate_toggle_name = 'animate_' + asset_version
animate_toggle = hou.ToggleParmTemplate(animate_toggle_name, 'Animate')
animate_toggle_to_int_name = 'animate_toggle_to_int_' + asset_version
animate_toggle_to_int = hou.IntParmTemplate(animate_toggle_to_int_name, 'Toggle To Int', 1, is_hidden=True, default_expression=('ch("' + animate_toggle_name + '")',))
set_folder.addParmTemplate(geo_label)
set_folder.addParmTemplate(hide_toggle)
set_folder.addParmTemplate(animate_toggle)
set_folder.addParmTemplate(animate_toggle_to_int)
try:
hda.parm('hide').setExpression('ch("../' + hide_toggle_name + '")')
hda.parm('shot').setExpression('chs("../shot")')
hda.parm('set').setExpression('chs("../set")')
hda.parm('source').setExpression('chs("../' + animate_toggle_to_int_name + '")')
except AttributeError, e:
message_gui.error("There was an error adding " + str(asset_name) + " to the set. Please make sure that the node exists and has all of the necessary parameters (hide, shot, set, source) and try again. Contact the pipeline team if you need help. We will continue assembling so you can see the output, but you will need to assemble this set again.", details=str(e))
except Exception, e:
message_gui.error('There was a problem with this node: ' + str(asset_name), details=str(e))
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"))
'Cylindrical (3ds max)', 'Shrink Wrap (3ds max)')
env_node.addSpareParmTuple(
hou.StringParmTemplate("file", "File", 1, (),
hou.parmNamingScheme.Base1,
hou.stringParmType.FileReference))
env_node.addSpareParmTuple(
hou.MenuParmTemplate("mapping_type", "Mapping Type", menu_items,
menu_items, 2))
env_node.addSpareParmTuple(
hou.FloatParmTemplate('h_rotation', 'Horiz. Rotation', 1, (0, ),
0.0, 360.0))
#env_node.addSpareParmTuple(hou.FloatParmTemplate('v_rotation', 'Vert. Rotation', 1, (0,), 0.0, 360.0))
env_node.addSpareParmTuple(
hou.ToggleParmTemplate('h_flip', 'Flip Horizontally', 0))
#env_node.addSpareParmTuple(hou.ToggleParmTemplate('v_flip', 'Flip Vertically', 0))
env_node.addSpareParmTuple(
hou.ToggleParmTemplate('ground_on', 'Ground Projection', 0))
env_node.addSpareParmTuple(
hou.FloatParmTemplate('ground_radius', 'Radius', 1, (1000, ), 0.0,
1000000.0, False, False,
hou.parmLook.Regular,
hou.parmNamingScheme.XYZW, '{ground_on 0}'))
env_node.addSpareParmTuple(
hou.FloatParmTemplate('overall_mult', 'Overall Mult', 1, (1, ),
0.0, 100.0))
env_node.addSpareParmTuple(
hou.FloatParmTemplate('inverse_gamma', 'Inverse Gamma', 1, (1, ),
def addVRayDisplamentParamTemplate(ptg):
if not ptg.findFolder("V-Ray"):
vfh_attrs.insertInFolderAfterLastTab(ptg, ptg, hou.FolderParmTemplate("vray", "V-Ray"))
if not ptg.findFolder(("V-Ray", "Displacement")):
vfh_attrs.insertInFolderAfterLastTab(ptg, ptg.findFolder('V-Ray'), hou.FolderParmTemplate("vray", "Displacement"))
folder = ("V-Ray", "Displacement")
# enable displacement
if not ptg.find("vray_use_displ"):
params = { }
params["tags"] = {'spare_category': 'vray'}
params["default_value"] = False
params["script_callback_language"] = hou.scriptLanguage.Python
ptg.appendToFolder(folder, hou.ToggleParmTemplate("vray_use_displ", "Use Displacement", **params))
# displacement type
if not ptg.find("vray_displ_type"):
params = { }
params["tags"] = {'spare_category': 'vray'}
params["default_value"] = 0
params["menu_items"]=(['0', '1', '2'])
params["menu_labels"]=(['From Shop Net', 'Displaced', 'Smoothed'])
params["conditionals"]={hou.parmCondType.DisableWhen: "{ vray_use_displ == 0 }"}
params["script_callback_language"] = hou.scriptLanguage.Python
ptg.appendToFolder(folder, hou.MenuParmTemplate("vray_displ_type", "Displacement Type", **params))
# params for vray_displ_type = 'shopnet'
if not ptg.findFolder("shopnet"):
params = { }
params["tags"] = {'spare_category': 'vray'}
params["folder_type"] = hou.folderType.Simple
params["conditionals"]={hou.parmCondType.HideWhen: "{ vray_displ_type != 0 }"}
ptg.appendToFolder(folder, hou.FolderParmTemplate("vray", "shopnet",**params))
shopnetFolder = ("V-Ray", "Displacement", "shopnet")
if not ptg.find("vray_displshoppath"):
params = { }
params["string_type"] = hou.stringParmType.NodeReference
params["tags"] = {'spare_category': 'vray', 'opfilter': '!!SHOP!!', 'oprelative': '.'}
params["script_callback_language"] = hou.scriptLanguage.Python
params["conditionals"]={hou.parmCondType.HideWhen: "{ vray_displ_type != 0 }", hou.parmCondType.DisableWhen: "{ vray_use_displ == 0 }"}
ptg.appendToFolder(shopnetFolder, hou.StringParmTemplate("vray_displshoppath", "Shop path", 1, **params))
# params for vray_displ_type = 'GeomDisplacedMesh'
if not ptg.findFolder("gdm"):
params = { }
params["tags"] = {'spare_category': 'vray'}
params["folder_type"] = hou.folderType.Simple
params["conditionals"]={hou.parmCondType.HideWhen: "{ vray_displ_type != 1 }"}
ptg.appendToFolder(folder, hou.FolderParmTemplate("vray", "gdm",**params))
gdmFolder = ("V-Ray", "Displacement", "gdm")
displDesc = vfh_json.getPluginDesc('GeomDisplacedMesh')
paramDescList = filter(lambda parmDesc: parmDesc['attr'] != 'displacement_tex_float', displDesc['PluginParams'])
for parmDesc in paramDescList:
vfh_attrs.addPluginParm(ptg, parmDesc, parmPrefix = 'GeomDisplacedMesh', parmFolder = gdmFolder)
# params for vray_displ_type = 'GeomStaticSmoothedMesh'
if not ptg.findFolder("gssm"):
params = { }
params["tags"] = {'spare_category': 'vray'}
params["folder_type"] = hou.folderType.Simple
params["conditionals"]={hou.parmCondType.HideWhen: "{ vray_displ_type != 2}"}
ptg.appendToFolder(folder, hou.FolderParmTemplate("vray", "gssm",**params))
gssmFolder = ("V-Ray", "Displacement", "gssm")
subdivDesc = vfh_json.getPluginDesc('GeomStaticSmoothedMesh')
paramDescList = filter(lambda parmDesc: parmDesc['attr'] != 'displacement_tex_float', subdivDesc['PluginParams'])
for parmDesc in paramDescList:
vfh_attrs.addPluginParm(ptg, parmDesc, parmPrefix = 'GeomStaticSmoothedMesh', parmFolder = gssmFolder)
parameters_check = hou.parm('/mat/Texture_Import/texture_parameters').eval()
# Check if using triplanar
triplanar_check = hou.parm('/mat/Texture_Import/triplanar_check').eval()
# Check if create triplanar parameters is checked
if triplanar_check:
triplanar_parameters_check = hou.parm('/mat/Texture_Import/triplanar_parameters').eval()
else:
triplanar_parameters_check = 0
# Create triplanar switch
if hou.node(matPath).parm('triPlanar') == None:
parm_group = hou.node(matPath).parmTemplateGroup()
parm_folder = hou.FolderParmTemplate('folder', 'Tri Planar')
parm_folder.addParmTemplate(hou.ToggleParmTemplate('triPlanar', 'Tri Planar', 0))
parm_group.append(parm_folder)
hou.node(matPath).setParmTemplateGroup(parm_group)
# Create material node
hou.node(matPath).createNode('redshift::Material','RS_Material')
#Set brdf to GGX
hou.node(matPath +'/RS_Material').parm('refl_brdf').set('1')
#Set fresnel type to metalness
hou.node(matPath +'/RS_Material').parm('refl_fresnel_mode').set('2')
#Create texture nodes
textureNodes = (
'diffuse',
'ao',
def _addDisplacementControls(ptg, vrayFolder):
ptg.appendToFolder(
vrayFolder,
hou.ToggleParmTemplate(
"vray_displ_use", "Use Displacement", **{
'tags': {
'spare_category': 'vray'
},
'default_value': True,
}))
ptg.appendToFolder(
vrayFolder,
hou.MenuParmTemplate(
"vray_displ_type", "Type", (['0', '1', '2']), **{
'tags': {
'spare_category': 'vray'
},
'menu_labels':
(["Displacement", "Subdivision", "From Material"]),
'default_value': 0,
'conditionals': {
hou.parmCondType.DisableWhen: "{ vray_displ_use == 0 }",
},
}))
ptg.appendToFolder(
vrayFolder,
hou.FolderParmTemplate(
"vray_displ_folder_GeomDisplacedMesh", "Displacement", **{
'parm_templates': (vfh_ptg_utils.getParmTemplatesFromDS(
"ObjectGeomDisplacedMesh", prefix="GeomDisplacedMesh")),
'folder_type':
hou.folderType.Simple,
'tags': {
'spare_category': 'vray'
},
'conditionals': {
hou.parmCondType.HideWhen:
"{ vray_displ_use == 0 } { vray_displ_type != 0 }"
},
}))
ptg.appendToFolder(
vrayFolder,
hou.FolderParmTemplate(
"vray_displ_folder_GeomStaticSmoothedMesh", "Subdivision", **{
'parm_templates': (vfh_ptg_utils.getParmTemplatesFromDS(
"ObjectGeomStaticSmoothedMesh",
prefix="GeomStaticSmoothedMesh")),
'folder_type':
hou.folderType.Simple,
'tags': {
'spare_category': 'vray'
},
'conditionals': {
hou.parmCondType.HideWhen:
"{ vray_displ_use == 0 } { vray_displ_type != 1 }"
},
}))
ptg.appendToFolder(
vrayFolder,
hou.FolderParmTemplate(
"vray_displ_folder_shopnet", "From Material", **{
'parm_templates': ([
hou.StringParmTemplate(
"vray_displ_shoppath", "Material", 1, **{
'string_type': hou.stringParmType.NodeReference,
'tags': {
'spare_category': 'vray',
'opfilter': '!!VOP!!',
'oprelative': '.',
}
})
]),
'folder_type':
hou.folderType.Simple,
'tags': {
'spare_category': 'vray',
},
'conditionals': {
hou.parmCondType.HideWhen:
"{ vray_displ_use == 0 } { vray_displ_type != 2 }",
},
}))
def promote_shape_parms(self,
curve,
node_to_promote_parms,
folder=["Transform"],
name=""):
"""
will promote the attributes of the curve to a given node, into a given ui folder
@param curve: the curve node that we will use
@param node_to_promote_parms: whats the node where are we going to put all the parameters
@param folder: in what folder tuple are we going to implement the promoted parameters
@param name: name of the parameter, (important so doesnt clash with other limbs)
@return:
"""
hou_rig.utils.promote_parm_to_ui(
curve.node("vopsop_streatch_and_squash").parm("stretch_ramp"),
node_to_promote_parms,
in_this_folder=folder,
parm_name=name + "_stretch_ramp")
hou_rig.utils.promote_parm_to_ui(
curve.node("vopsop_streatch_and_squash").parm("stretch_ramp_mult"),
node_to_promote_parms,
in_this_folder=folder,
join_with_next_parm=True,
parm_name=name + "_stretch_ramp_mult")
hou_rig.utils.promote_parm_to_ui(
curve.node("vopsop_streatch_and_squash").parm("stretch_cap"),
node_to_promote_parms,
in_this_folder=folder,
parm_name=name + "_stretch_cap")
# #-----------------------------------------------------------------------------------------------
hou_rig.utils.promote_parm_to_ui(
curve.node("vopsop_streatch_and_squash").parm("squash_ramp"),
node_to_promote_parms,
in_this_folder=folder,
parm_name=name + "_squash_ramp")
hou_rig.utils.promote_parm_to_ui(
curve.node("vopsop_streatch_and_squash").parm("squash_ramp_mult"),
node_to_promote_parms,
in_this_folder=folder,
join_with_next_parm=True,
parm_name=name + "_squash_ramp_mult")
hou_rig.utils.promote_parm_to_ui(
curve.node("vopsop_streatch_and_squash").parm("squash_cap"),
node_to_promote_parms,
in_this_folder=folder,
parm_name=name + "_squash_cap")
dcurve_toggle = hou.ToggleParmTemplate(name + "_display_curve",
"Display Curve",
default_value=False)
promoted_dcurve_toggle = hou_rig.utils.parm_to_ui(
node_to_promote_parms, dcurve_toggle, in_this_folder=folder)
hou_rig.utils.togle_display_nodes(promoted_dcurve_toggle, [curve])
if curve.node("OUT_viz"):
sq_curve_toggle = hou.ToggleParmTemplate(
name + "_display_stretch_and_squash",
"Display Stretch and Squash",
default_value=False)
promoted_sq_curve_toggle = hou_rig.utils.parm_to_ui(
node_to_promote_parms, sq_curve_toggle, in_this_folder=folder)
curve.node("switch1").parm("input").set(promoted_sq_curve_toggle)
def very_nice_camera_rig(focal_length=35,
horizontal_film_aperture=36,
vertical_film_aperture=24):
"""creates a very nice camera rig where the Heading, Pitch and Roll controls are on different transform nodes
allowing more control on the camera movement
:param focal_length:
:param horizontal_film_aperture:
:param vertical_film_aperture:
"""
obj_context = hou.node("/obj")
camera = obj_context.createNode("cam")\
# set camera attributes
camera.parm("focal").set(focal_length)
# set the film back in millimeters (yeah)
camera.parm("aperture").set(horizontal_film_aperture)
main_ctrl = obj_context.createNode("null", "main_ctrl1")
heading_ctrl = obj_context.createNode("null", "heading_ctrl1")
pitch_ctrl = obj_context.createNode("null", "pitch_ctrl1")
roll_ctrl = obj_context.createNode("null", "roll_ctrl1")
# create DAG hierarchy
camera.setInput(0, roll_ctrl)
roll_ctrl.setInput(0, pitch_ctrl)
pitch_ctrl.setInput(0, heading_ctrl)
heading_ctrl.setInput(0, main_ctrl)
# Parameters
# -----------------------------------------------------------
# Focal Length And Focal Plane Controls
# Create space input0 for rs proxy output node
# Focal Length
ptg = main_ctrl.parmTemplateGroup()
ptg.append(
hou.FloatParmTemplate('focal',
'Focal Length',
1,
default_value=[focal_length],
min=1.0,
min_is_strict=True))
ptg.append(
hou.FloatParmTemplate('aperture',
'Aperture',
1,
default_value=[horizontal_film_aperture],
min=1.0,
min_is_strict=True))
ptg.append(
hou.ToggleParmTemplate('useDepthOfField',
'Use Depth Of Field',
default_value=False))
ptg.append(
hou.FloatParmTemplate('fstop',
'f-stop',
1,
default_value=[2.8],
min=0.01,
min_is_strict=True))
ptg.append(
hou.FloatParmTemplate('focusOffset',
'Focus Offset',
1,
default_value=[0]))
ptg.append(
hou.FloatParmTemplate('offsetX',
'Offset X (PanH)',
1,
default_value=[0]))
ptg.append(
hou.FloatParmTemplate('offsetY',
'Offset Y (PanV)',
1,
default_value=[0]))
ptg.append(
hou.FloatParmTemplate('offsetZ',
'Offset Z (Depth)',
1,
default_value=[0]))
ptg.append(hou.FloatParmTemplate('roll1', 'Roll', 1, default_value=[0]))
ptg.append(hou.FloatParmTemplate('pitch', 'Pitch', 1, default_value=[0]))
ptg.append(
hou.FloatParmTemplate('heading', 'Heading', 1, default_value=[0]))
ptg.append(hou.FloatParmTemplate('camerar', 'Camera Rotation', 3))
main_ctrl.setParmTemplateGroup(ptg)
translate_parm = ptg.find("t")
ptg
main_ctrl.parm("focal").set(focal_length)
main_ctrl.parm("aperture").set(horizontal_film_aperture)
main_ctrl_name = main_ctrl.name()
camera.parm("focal").setExpression("ch(\"../%s/focal\")" % main_ctrl_name)
camera.parm("aperture").setExpression("ch(\"../%s/aperture\")" %
main_ctrl_name)
# Depth Of Field
camera.parm("RS_campro_dofEnable").setExpression(
"ch(\"../%s/useDepthOfField\")" % main_ctrl_name)
# F-Stop
camera.parm("fstop").setExpression("ch(\"../%s/fstop\")" % main_ctrl_name)
# Camera Local Position and Offsets
# Focus Offset
camera.parm("tx").setExpression('ch("../%s/offsetX")' % main_ctrl_name)
camera.parm("ty").setExpression('ch("../%s/offsetY")' % main_ctrl_name)
camera.parm("tz").setExpression('ch("../%s/offsetZ")' % main_ctrl_name)
# Back to focal plane
camera.parm("focus").setExpression(
'ch("../{main_ctrl}/offsetZ") + ch("../{main_ctrl}/focusOffset")'.
format(main_ctrl=main_ctrl_name))
# -----------------------------------------------------------
# Camera Orientation
roll_ctrl.parm("rz").setExpression('ch("../%s/roll1")' % main_ctrl_name)
pitch_ctrl.parm("rx").setExpression('ch("../%s/pitch")' % main_ctrl_name)
heading_ctrl.parm("ry").setExpression('ch("../%s/heading")' %
main_ctrl_name)
camera.parm("rx").setExpression('ch("../%s/camerarx")' % main_ctrl_name)
camera.parm("ry").setExpression('ch("../%s/camerary")' % main_ctrl_name)
camera.parm("rz").setExpression('ch("../%s/camerarz")' % main_ctrl_name)
heading_ctrl.parm("tx").lock(True)
heading_ctrl.parm("ty").lock(True)
heading_ctrl.parm("tz").lock(True)
heading_ctrl.parm("rx").lock(True)
heading_ctrl.parm("ry").lock(True)
heading_ctrl.parm("rz").lock(True)
heading_ctrl.parm("sx").lock(True)
heading_ctrl.parm("sy").lock(True)
heading_ctrl.parm("sz").lock(True)
pitch_ctrl.parm("tx").lock(True)
pitch_ctrl.parm("ty").lock(True)
pitch_ctrl.parm("tz").lock(True)
pitch_ctrl.parm("rx").lock(True)
pitch_ctrl.parm("ry").lock(True)
pitch_ctrl.parm("rz").lock(True)
pitch_ctrl.parm("sx").lock(True)
pitch_ctrl.parm("sy").lock(True)
pitch_ctrl.parm("sz").lock(True)
roll_ctrl.parm("tx").lock(True)
roll_ctrl.parm("ty").lock(True)
roll_ctrl.parm("tz").lock(True)
roll_ctrl.parm("rx").lock(True)
roll_ctrl.parm("ry").lock(True)
roll_ctrl.parm("rz").lock(True)
roll_ctrl.parm("sx").lock(True)
roll_ctrl.parm("sy").lock(True)
roll_ctrl.parm("sz").lock(True)
camera.parm("tx").lock(True)
camera.parm("ty").lock(True)
camera.parm("tz").lock(True)
camera.parm("rx").lock(True)
camera.parm("ry").lock(True)
camera.parm("rz").lock(True)
camera.parm("sx").lock(True)
camera.parm("sy").lock(True)
camera.parm("sz").lock(True)
