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)