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 create_subnet(geoNode,boxNode):
subnetGeo = geoNode.createNode('subnet', "cutterTool")
subnetLocation = hou.node('/obj/fractured_geo/subnet/cutterTool/')
parm_group = subnetGeo.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate("folder", "Cutter Tool")
parm_folder.addParmTemplate(hou.IntParmTemplate("cutterNum", "Number of Cutters", 1, (10, 100, 100),(1), (24)))
parm_folder.addParmTemplate(hou.IntParmTemplate("detailValue", "Detail Value", 1, (1, 100, 100),(1), (24)))
parm_group.append(parm_folder)
subnetGeo.setParmTemplateGroup(parm_group)
subnetGeo.setInput(0, boxNode)
subnetGeo.moveToGoodPosition()
return subnetLocation
def addTargetNodeController(camera, camera_target):
constraints = camera.createNode('chopnet', 'constraints')
parm_group = constraints.parmTemplateGroup()
parm_group.addParmTemplate(
hou.IntParmTemplate('chopnet_rate', 'CHOP Rate', 1))
parm_group.addParmTemplate(
hou.IntParmTemplate('motionsamples', 'CHOP Motion Samples', 1))
constraints.setParmTemplateGroup(parm_group)
constraints.parm('chopnet_rate').setExpression(
'$FPS * ch("motionsamples")')
constraints.parm('motionsamples').setExpression('$CHOPMOTIONSAMPLES')
constraints.moveToGoodPosition()
camera.parm('constraints_on').set(1)
camera.parm('constraints_path').set('constraints')
constraintlookat = constraints.createNode('constraintlookat', 'lookat')
constraintlookat.parm('vex_range').set(1)
constraintlookat.parm('vex_rate').setExpression('ch("../chopnet_rate")')
constraintlookat.parm('export').set('../..')
constraintlookat.parm('gcolorr').set(0)
constraintlookat.parm('gcolorg').set(0)
constraintlookat.parm('gcolorb').set(0.9)
constraintgetworldspace = constraints.createNode('constraintgetworldspace',
'getworldspace')
constraintgetworldspace.parm('obj_path').set('../..')
constraintgetworldspace.parm('vex_range').set(1)
constraintgetworldspace.parm('vex_rate').setExpression(
'ch("../chopnet_rate")')
constraintgetworldspace.parm('export').set('../..')
constraintgetworldspace.parm('gcolorr').set(0.9)
constraintgetworldspace.parm('gcolorg').set(0)
constraintgetworldspace.parm('gcolorb').set(0)
constraintobject = constraints.createNode('constraintobject',
camera_target.name())
constraintobject.parm('obj_path').set('../../../' + camera_target.name())
constraintobject.parm('vex_range').set(1)
constraintobject.parm('vex_rate').setExpression('ch("../chopnet_rate")')
constraintobject.parm('export').set('../..')
constraintobject.parm('gcolorr').set(0.9)
constraintobject.parm('gcolorg').set(0.9)
constraintobject.parm('gcolorb').set(0)
constraintlookat.setInput(0, constraintgetworldspace)
constraintlookat.setInput(1, constraintobject)
constraints.layoutChildren()
def process(self, context, plugin):
# Get the errored instances
failed = []
for result in context.data["results"]:
if (result["error"] is not None and result["instance"] is not None
and result["instance"] not in failed):
failed.append(result["instance"])
# Apply pyblish.logic to get the instances for the plug-in.
instances = pyblish.api.instances_by_plugin(failed, plugin)
plugin = plugin()
for instance in instances:
node = instance[0]
templates = []
templates.append(
hou.IntParmTemplate("deadlineChunkSize",
"Chunk Size",
1,
default_value=(1, )))
templates.append(
hou.IntParmTemplate("deadlinePriority",
"Priority",
1,
default_value=(50, )))
templates.append(
hou.StringParmTemplate("deadlinePool",
"Pool",
1,
default_value=("", )))
templates.append(
hou.IntParmTemplate("deadlineConcurrentTasks",
"Concurrent Tasks",
1,
default_value=(1, )))
parm_group = node.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate("folder", "Deadline")
for template in templates:
try:
parm_folder.addParmTemplate(template)
except:
self.log.debug("Could not add \"{0}\"".format(template))
parm_group.append(parm_folder)
node.setParmTemplateGroup(parm_group)
def createNoiseFolderParmTemplate(id):
a_parm = hou.FloatParmTemplate('a'+id,'a'+id,1,default_value = (1,))
f_parm = hou.FloatParmTemplate('f'+id,'f'+id,1,default_value = (1,))
t_parm = hou.IntParmTemplate('t'+id,'t'+id,1,default_value = (3,))
r_parm = hou.FloatParmTemplate('r'+id,'r'+id,1,default_value = (0.5,))
noise_folder = hou.FolderParmTemplate('noise'+id,'Noise'+id,parm_templates = (a_parm,f_parm),folder_type = hou.folderType.Simple)
return noise_folder
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 get_new_parameter(self, parm):
# ch, chf - float
# chv - vector
# chp - point
# chs - string
# chi- int
# chramp - ramp
if parm['func'] == 'ch' or parm['func'] == 'chf':
return hou.FloatParmTemplate(parm['name'], parm['name'].title(), 1)
elif parm['func'] == 'chv':
return hou.FloatParmTemplate(parm['name'], parm['name'].title(), 3)
elif parm['func'] == 'chs':
return hou.StringParmTemplate(parm['name'], parm['name'].title(), 1)
elif parm['func'] == 'chi':
return hou.IntParmTemplate(parm['name'], parm['name'].title(), 1)
elif parm['func'] == 'chramp':
if parm['type'] == 'vector':
return hou.RampParmTemplate(parm['name'], parm['name'].title(), hou.rampParmType.Color )
else:
return hou.RampParmTemplate(parm['name'], parm['name'].title(), hou.rampParmType.Float )
elif parm['func'] == 'chp':
return hou.FloatParmTemplate(parm['name'], parm['name'].title(), 4)
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 createTurbNoiseFolderParmTemplate(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=(5, ))
r_parm = hou.FloatParmTemplate('r' + id,
'Rough' + id,
1,
default_value=(0.5, ))
at_parm = hou.FloatParmTemplate('at' + id,
'Atten' + id,
1,
default_value=(1.0, ))
type_parm = hou.StringParmTemplate('type'+id,'NoiseType'+id,1,default_value = ("a",),\
menu_items =("p","o","s","a","x","c"),\
menu_labels =("Perlin","OriginalPerlin","SparseConvultion","Alligator","Simplex","CorrectedPerlin"),\
join_with_next=True)
noise_folder = hou.FolderParmTemplate('noise'+id,'Noise'+id,\
parm_templates = (a_parm,f_parm,t_parm,r_parm,at_parm,type_parm),\
folder_type = hou.folderType.Simple)
return noise_folder
def addVRayObjectIdParamTemplate(node):
parm_group = node.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate('folder', 'V-Ray Object')
parm_folder.addParmTemplate(
hou.IntParmTemplate('vray_objectID', 'Object ID', 1))
parm_group.append(parm_folder)
node.setParmTemplateGroup(parm_group)
def boxParmInt(p, dim, parent=None):
name = parmName(p.name, prefix=parent)
label = parmLabel(p)
default_box = p.defaultValue.value
default = []
default = list(default_box.min)
default.extend(list(default_box.max))
min_val = 0
max_val = 10
min_lock = max_lock = False
parm = hou.IntParmTemplate(name,
label,
dim * 2,
default_value=default,
min=min_val,
max=max_val,
min_is_strict=min_lock,
max_is_strict=max_lock,
naming_scheme=hou.parmNamingScheme.Base1,
help=p.description)
box = p.getTypedValue()
initialValue = list(box.min)
initialValue.extend(list(box.max))
return {'name': name, 'tuple': parm, 'initialValue': initialValue}
def addParmForType(location='Save to File'):
target = ptg.findIndicesForFolder(
location) # find Save to File folder
# Create the parm to Add
houParmTmp = hou.IntParmTemplate(parm, parm, 1)
ptg.appendToFolder(target, houParmTmp)
node.setParmTemplateGroup(ptg)
#set default value
node.parm(parm).set(value)
def save_tabs_to_hip(self):
# collect data
tabs = []
for i in range(self.count()):
c = self.widget(i)
if c.is_backup:
continue
text = c.edit.text()
if c.parm:
type = 'parm'
path = c.parm.path()
elif c.file:
type = 'file'
path = c.file
elif c.section:
type = 'section'
path = '/'.join([
c.section.definition().nodeType().name(),
c.section.name()
])
else:
type = 'empty'
path = ''
tabs.append(dict(text=text, type=type, path=path))
if not tabs:
return
# create node
self.clear_tabs_node()
node = hou.node('/obj').createNode('vopnet')
node.setName(tabsNodeName)
# create template
grp = node.parmTemplateGroup()
for i, tab in enumerate(tabs):
tp = hou.StringParmTemplate('type%s' % i, 'type%s' % i, 1,
(tab['type'], ))
path = hou.StringParmTemplate('path%s' % i, 'path%s' % i, 1,
(tab['path'], ))
text = hou.StringParmTemplate('text%s' % i, 'text%s' % i, 1,
(tab['text'], ))
text.setTags({"editor": "1"})
name = os.path.basename(tab['path'])
if not name:
name = 'VEX Code%s' % i
f = hou.FolderParmTemplate(name,
name.replace('.', '_').lower(),
(tp, path, text))
grp.addParmTemplate(f)
ind = hou.IntParmTemplate('tabs_active_index', 'tabs_active_index', 1,
(self.currentIndex(), ))
grp.addParmTemplate(ind)
node.setParmTemplateGroup(grp)
node.hide(True)
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 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_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 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 intParm(p, dim=1, parent=None):
name = parmName(p.name, prefix=parent)
label = parmLabel(p)
# only simple floats have min/max values
if dim == 1:
default = [(p.defaultValue.value)]
initialValue = [p.getTypedValue()]
min_val = 0
max_val = 10
min_lock = max_lock = False
naming = hou.parmNamingScheme.Base1
if p.hasMinValue():
min_val = p.minValue
min_lock = True
if p.hasMaxValue():
max_val = p.maxValue
max_lock = True
else:
default = list(p.defaultValue.value)
initialValue = list(p.getTypedValue())
min_val = 0
max_val = 10
min_lock = max_lock = False
naming = hou.parmNamingScheme.XYZW
# Houdini can only handle presets for dim 1 ints, and even then its quite messy...
if dim == 1 and p.presetsOnly:
parm = hou.MenuParmTemplate(name,
label,
default_value=p.presetValues().index(
p.defaultValue),
help=p.description,
**presetsMenuArgs(p))
initialValue = [p.presetValues().index(p.getValue())]
else:
parm = hou.IntParmTemplate(name,
label,
dim,
default_value=default,
min=min_val,
max=max_val,
min_is_strict=min_lock,
max_is_strict=max_lock,
naming_scheme=naming,
help=p.description)
return {'name': name, 'tuple': parm, 'initialValue': initialValue}
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 abc():
""" cree un rop output dans /out et le recharge dans le context d'origine
cela permet d'enchainer les depandences dans /out et de les relires automatiquement
dans dans le contexte d'origine
"""
help(abc)
import hou
nodeSelect = hou.selectedNodes()
black = hou.Color((0, 0, 0))
pink = hou.Color((0.98, 0.275, 0.275))
out = hou.node("/out")
for node in nodeSelect:
parent = node.parent() #hou.node("..")
parentString = parent.name()
getName = node.name()
connectNode = node.outputs()
outNull = node.createOutputNode("null", getName.upper())
outNull.setPosition(node.position())
outNull.move([0, -.75])
outNull.setColor(black)
#set read node to read myWriteGeo
myFile = outNull.createOutputNode("alembic",
getName.upper() + "_CACHE")
myFile.setColor(pink)
myFile.setParms({
'fileName':
'$HIP/cache/rop_sfx/abc/$OS/v`padzero(3,chs("/out/$OS/version"))`/$OS.abc'
})
#set write geo in out context
myWriteGeo = out.createNode("alembic", getName.upper() + "_CACHE")
#set parm
myWriteGeo.setParms({"use_sop_path": 1})
myWriteGeo.setParms(
{"sop_path": "/obj/" + parentString + "/" + getName.upper()})
myWriteGeo.setParms({
"filename":
"$HIP/cache/rop_sfx/abc/$OS/v`padzero(3, ch('version'))`/$OS.abc"
})
myWriteGeo.setParms({"trange": "normal"})
#add create param for versionning
parm_group = myWriteGeo.parmTemplateGroup()
versionParm = hou.IntParmTemplate("version", "Version", 1)
target_folder = ("Main")
parm_group.appendToFolder(target_folder, versionParm)
myWriteGeo.setParmTemplateGroup(parm_group)
def add_TMP(attr_name, tmp_type, current_tmpparm):
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))
return current_tmpparm
def bgeo():
""" cree un rop output dans /out et le recharge dans le context d'origine
cela permet d'enchainer les depandences dans /out et de les relires automatiquement
dans dans le contexte d'origine
"""
help(bgeo)
import hou
nodeSelect = hou.selectedNodes()
black = hou.Color((0, 0, 0))
pink = hou.Color((0.98, 0.275, 0.275))
out = hou.node("/out")
for node in nodeSelect:
parent = node.parent() #hou.node("..")
parentString = parent.name()
getName = node.name()
connectNode = node.outputs()
outNull = node.createOutputNode("null", getName.upper())
outNull.setPosition(node.position())
outNull.move([0, -.75])
outNull.setColor(black)
#set read node to read myWriteGeo
myFile = outNull.createOutputNode("file", getName.upper() + "_CACHE")
myFile.setColor(pink)
myFile.setParms({
'file':
'$HIP/cache/rop_sfx/bgeo.sc/$OS/v`padzero(3,chs("/out/$OS/version"))`/$OS.$F5.bgeo.sc'
})
myWriteGeo = out.createNode("geometry", getName.upper() + "_CACHE")
myWriteGeo.setParms(
{"soppath": "/obj/" + parentString + "/" + getName.upper()})
myWriteGeo.setParms({
"sopoutput":
"$HIP/cache/rop_sfx/bgeo.sc/$OS/v`padzero(3, ch('version'))`/$OS.$F5.bgeo.sc"
})
myWriteGeo.setParms({"trange": "normal"})
#add create param for versionning and export format
parm_group = myWriteGeo.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate("folder", "version")
parm_folder.addParmTemplate(
hou.IntParmTemplate("version", "Version", 1))
parm_group.append(parm_folder)
myWriteGeo.setParmTemplateGroup(parm_group)
def createFlowNoiseFolderParmTemplate(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,))
flow = hou.FloatParmTemplate('flow'+id,'Flow'+id,1,default_value = (0,))
flowrate = hou.FloatParmTemplate('flowrate'+id,'FlowRate'+id,1,default_value = (1,))
selfAdvect = hou.FloatParmTemplate('selfAdvect'+id,'SelfAdvect'+id,1,default_value = (0,))
noise_folder = hou.FolderParmTemplate('noise'+id,'Noise'+id,\
parm_templates = (a_parm,f_parm,t_parm,o_parm,r_parm,flow,flowrate,selfAdvect),\
folder_type = hou.folderType.Simple)
return noise_folder
def IntParmTemplate(parmName, parmLabel, parmDesc):
parmArgs = {}
parmArgs['naming_scheme'] = hou.parmNamingScheme.Base1
parmArgs['num_components'] = 1
if 'default' in parmDesc:
parmArgs['default_value'] = [parmDesc['default']]
if 'ui' in parmDesc:
parmArgs['min_is_strict'] = False
parmArgs['max_is_strict'] = False
ui_desc = parmDesc['ui']
# Use soft bounds and allow manual override
if 'soft_min' in ui_desc:
parmArgs['min'] = ui_desc['soft_min']
if 'soft_max' in ui_desc:
parmArgs['max'] = ui_desc['soft_max']
return hou.IntParmTemplate(parmName, parmLabel, **parmArgs)
def createCurlNoiseFolderParmTemplate(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,))
at_parm = hou.FloatParmTemplate('at'+id,'Atten'+id,1,default_value = (0.5,))
ef_parm = hou.FloatParmTemplate('ef'+id,'Effect'+id,1,default_value = (1,))
type_parm = hou.StringParmTemplate('type'+id,'NoiseType'+id,1,default_value = ("p",),\
menu_items =("p","o","s","a","x"),\
menu_labels =("Perlin","OriginalPerlin","SparseConvultion","Alligator","Simplex"),\
join_with_next=True)
sdf_parm = hou.StringParmTemplate('sdf'+id,'SDF'+id,1,default_value = ("",),\
default_expression=("i2()",))
noise_folder = hou.FolderParmTemplate('noise'+id,'Noise'+id,\
parm_templates = (a_parm,f_parm,t_parm,o_parm,r_parm,at_parm,type_parm,sdf_parm,ef_parm),\
folder_type = hou.folderType.Simple)
return noise_folder
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()
def addMaterialOptions(geo, groups):
hou_parm_template_group = geo.parmTemplateGroup()
material_folder=hou.FolderParmTemplate('material_folder','Material',folder_type=hou.folderType.Tabs)
#material_selection_folder=hou.FolderParmTemplate('material_selection_folder','material_selection_folder',folder_type=hou.folderType.Tabs)
group_names = list()
for group in groups:
group_names.append(group.name())
for group in groups:
num_materials_folder = hou.FolderParmTemplate('num_materials', group.name()+' Materials', folder_type=hou.folderType.Simple)
num_materials_folder.setDefaultValue(1)
material_expression = 'chs("'+group.name()+'_material"+ch("'+group.name()+'_slider"))'
assigned_material = hou.StringParmTemplate(group.name()+'_assigned_material', 'Assigned Material', 1,default_expression=([material_expression]))
material_selection = hou.IntParmTemplate(group.name()+'_slider','Material Selection',1,default_value=([1]),min=1,min_is_strict=True)
#group = hou.StringParmTemplate(group.name(), 'Group', 1, default_value=([group.name()]))
#num_materials_folder.addParmTemplate(group)
num_materials_folder.addParmTemplate(assigned_material)
num_materials_folder.addParmTemplate(material_selection)
groups = hou.IntParmTemplate(group.name()+'_group','Material Selector',1,default_value=([1]),min=1,min_is_strict=True)
#hide_materials = hou.ToggleParmTemplate(group.name()+'_hider','Hide Materials',default_value=False)
materials=hou.FolderParmTemplate(group.name()+'_materials', 'Available Materials', folder_type=hou.folderType.MultiparmBlock)
material=hou.StringParmTemplate(group.name()+'_material#','Material',1,default_value=(['']),string_type=hou.stringParmType.NodeReference)
print material
material.setTags({'oprelative': '.','opfilter':'!!CUSTOM/MATERIAL!!'})
materials.addParmTemplate(material)
num_materials_folder.addParmTemplate(materials)
mat= hou.FolderParmTemplate('material',group.name(),folder_type=hou.folderType.Collapsible)
mat.addParmTemplate(num_materials_folder)
material_folder.addParmTemplate(mat)
#material_selection_folder.addParmTemplate(mat)
#add displacement_bound to render man folder
displacement_bound = hou.properties.parmTemplate(get_latest_prman(),"ri_dbound")
try:
rMan_folder = hou_parm_template_group.findFolder('RenderMan')
#rMan_folder.append(displacement_bound)
# hou_parm_template_group.append(rMan_folder)
#hou_parm_template_group.appendToFold(('RenderMan'),displacement_bound)
except:
print 'error adding displacement_bound'
groups = hou.StringParmTemplate('group#', 'Group', 1, menu_items=group_names, menu_type=hou.menuType.StringToggle)
materials = hou.StringParmTemplate('mat_path#', 'Material', 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)
materials
hou_parm_template_group.append(material_folder)
geo.setParmTemplateGroup(hou_parm_template_group)
return geo
def CreateCanoeRenderTab(n):
ptg = n.parmTemplateGroup()
folder = hou.FolderParmTemplate("shortcuts", "CANOE")
Render_Cam = hou.StringParmTemplate(
"RS_renderCamera2",
"Render Camera",
1,
default_value=(["/obj/RS_Cam"]),
string_type=hou.stringParmType.NodeReference)
Render_Cam.setTags({
"autoscope": "0000000000000000",
"opfilter": "!!OBJ/CAMERA!!",
"oprelative": "."
})
folder.addParmTemplate(Render_Cam)
Output = hou.StringParmTemplate(
"RS_outputFileNamePrefix2",
"Common File Prefix",
1,
default_value=(["$JOB/Render/001_InitRender/$F4.exr"]),
string_type=hou.stringParmType.FileReference,
item_generator_script="opmenu -l . RS_outputFileNamePrefix",
item_generator_script_language=hou.scriptLanguage.Hscript,
menu_type=hou.menuType.StringReplace)
folder.addParmTemplate(Output)
folder.addParmTemplate(hou.SeparatorParmTemplate("sep1"))
arhive_toggle = hou.ToggleParmTemplate(
"RS_archive_enable2",
"Export .rs Proxy File",
default_value=False,
default_expression='off',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(arhive_toggle)
archive = hou.StringParmTemplate(
"RS_archive_file2",
"Filename",
1,
default_value=(["$HIP/filename.$F4.rs"]),
naming_scheme=hou.parmNamingScheme.Base1,
string_type=hou.stringParmType.FileReference,
item_generator_script="opmenu -l . RS_archive_file",
item_generator_script_language=hou.scriptLanguage.Hscript,
menu_type=hou.menuType.StringReplace)
folder.addParmTemplate(archive)
folder.addParmTemplate(hou.SeparatorParmTemplate("sep2"))
Motion_toggle = hou.ToggleParmTemplate(
"MotionBlurEnabled2",
"Enable Motion Blur",
default_value=False,
default_expression='off',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(Motion_toggle)
Fog_toggle = hou.ToggleParmTemplate(
"VolLightingEnabled2",
"Enable Global Fog",
default_value=False,
default_expression='off',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(Fog_toggle)
AOV_toggle = hou.ToggleParmTemplate(
"RS_aovAllAOVsDisabled2",
"Disable All AOVs",
default_value=True,
default_expression='on',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(AOV_toggle)
Tesselation_Toggle = hou.ToggleParmTemplate(
"TessellationDisplacementEnable2",
"Enable Tessellation And Displacement",
default_value=True,
default_expression='on',
default_expression_language=hou.scriptLanguage.Hscript)
folder.addParmTemplate(Tesselation_Toggle)
folder.addParmTemplate(hou.SeparatorParmTemplate("sep3"))
# Code for parameter template
# Deadline Parameters
deadline_priority = hou.IntParmTemplate("deadline_priority",
"Deadline Priority",
1,
default_value=([50]),
min=1,
max=90,
min_is_strict=True,
max_is_strict=True)
folder.addParmTemplate(deadline_priority)
deadline_jobname = hou.StringParmTemplate("deadline_jobname",
"Deadline Jobname",
1,
default_value=(["$HIPNAME"]))
folder.addParmTemplate(deadline_jobname)
DeadlineFastRender_btn = hou.ButtonParmTemplate(
"submit_to_deadline_allGpus", "Deadline Render")
DeadlineFastRender_btn.setScriptCallback(
"import lz;lz.lzDeadline.submitRS2Deadline(hou.pwd(),one_task_per_gpu=False)"
)
DeadlineFastRender_btn.setScriptCallbackLanguage(hou.scriptLanguage.Python)
folder.addParmTemplate(DeadlineFastRender_btn)
DeadlineRender_btn = hou.ButtonParmTemplate(
"submit_to_deadline", "Deadline Render (1f per GPU)")
DeadlineRender_btn.setScriptCallback(
"import lz;lz.lzDeadline.submitRS2Deadline(hou.pwd())")
DeadlineRender_btn.setScriptCallbackLanguage(hou.scriptLanguage.Python)
folder.addParmTemplate(DeadlineRender_btn)
BatchProxy_btn = hou.ButtonParmTemplate("batch_proxy", "Batch Proxy")
BatchProxy_btn.setScriptCallback(
"import hou;hou.hipFile.save();import lz;lz.lzRS_Shelf.BatchProxy(hou.pwd())"
)
BatchProxy_btn.setScriptCallbackLanguage(hou.scriptLanguage.Python)
folder.addParmTemplate(BatchProxy_btn)
before = "RS_rrs2"
ptg.insertAfter(before, folder)
n.setParmTemplateGroup(ptg)
parms = [
"RS_renderCamera", "RS_outputFileNamePrefix", "RS_archive_enable",
"RS_archive_file", "MotionBlurEnabled", "VolLightingEnabled",
"RS_aovAllAOVsDisabled", "TessellationDisplacementEnable"
]
for parm in parms:
n.parm(parm).set(n.parm(parm + "2"))
def resizeFluidSops(kwargs):
""" Select fluid and set it up to be resizeable.
"""
sceneviewer = toolutils.activePane(kwargs)
if not isinstance(sceneviewer, hou.SceneViewer):
raise hou.Error("Invalid pane type for this operation.")
# Select the target fluid box.
fluidobjects = sceneviewer.selectDynamics(
prompt="Select fluid box to resize. Press Enter to complete.",
allow_multisel=False)
if len(fluidobjects) < 1:
raise hou.Error(
"No fluid container selected to set initial conditions.")
fluidobject = fluidobjects[0]
fluidnode = doptoolutils.getDopObjectCreator(fluidobject)
if fluidnode is None:
raise hou.Error("No fluid object node found.")
""" Create and configure the reference container for resizing.
"""
dopnet = doptoolutils.getCurrentDopNetwork()
refobject = fluidnode.parent().parent().createNode(
"geo", "fluid_resize_container", run_init_scripts=False)
fluidfields = refobject.createNode("dopio", "fluidfields")
fluidfields.parm("doppath").set(dopnet.path())
fluidfields.setParmExpressions(
{"defobj": "chs(\"" + fluidnode.path() + "/object_name\")"})
fluidfields.parm("fields").set(2)
fluidfields.parm("fieldname1").set("density")
fluidfields.parm("fieldname2").set("vel")
parms = refobject.parmTemplateGroup()
parms.hideFolder("Transform", True)
parms.hideFolder("Material", True)
parms.hideFolder("Render", True)
parms.hideFolder("Misc", True)
ref_folder = hou.FolderParmTemplate("ref_folder", "Resize Container")
ref_folder.addParmTemplate(
hou.IntParmTemplate(
"nptsperarea",
"Scatter per Area",
1,
default_value=([5000]),
min=1000,
max=20000,
help="Scatter points on simulated density to calculate bounds"))
ref_folder.addParmTemplate(
hou.FloatParmTemplate(
"treshold",
"Density Treshold",
1,
default_value=([0]),
min=0,
max=1,
help="Delete density below this value prior to scattering points"))
ref_folder.addParmTemplate(hou.SeparatorParmTemplate("sep1"))
ref_folder.addParmTemplate(
hou.LabelParmTemplate("merge_source", "Merge Sources"))
ref_folder.addParmTemplate(
hou.ButtonParmTemplate(
"update",
"Update sources",
help="Push this to update ObjectMerge node inside",
tags={
"script_callback":
"import adddoputils; adddoputils.updateSourcesButton()",
"script_callback_language": "python"
}))
ref_folder.addParmTemplate(
hou.IntParmTemplate(
"source_activation",
"All Sources Activation",
1,
default_value=([1]),
min=0,
max=1,
min_is_strict=True,
max_is_strict=True,
help=
"Activation of merging all of the listed sources and additional objects"
))
ref_folder.addParmTemplate(
hou.MenuParmTemplate(
"xformtype", "Transform", "012",
("None", "Into This Object", "Into Specified Object"), 1))
ref_folder.addParmTemplate(
hou.StringParmTemplate("xformpath",
"Transform object",
1,
"",
hou.parmNamingScheme.Base1,
hou.stringParmType.NodeReference,
disable_when=("{ xformtype != 2 }")))
sources_folder = hou.FolderParmTemplate(
"source_folder",
"Sources to Merge",
folder_type=hou.folderType.MultiparmBlock)
sources_folder.addParmTemplate(
hou.ToggleParmTemplate("source_activation#",
"Source # Activation",
default_value=True))
sources_folder.addParmTemplate(
hou.StringParmTemplate("objpath#", "Object #", 1, "",
hou.parmNamingScheme.Base1,
hou.stringParmType.NodeReference))
sources_folder.addParmTemplate(
hou.StringParmTemplate("group#", "Group #", 1, "",
hou.parmNamingScheme.Base1,
hou.stringParmType.Regular))
ref_folder.addParmTemplate(sources_folder)
parms.append(ref_folder)
refobject.setParmTemplateGroup(parms)
keep_density = refobject.createNode("blast", "keep_density")
keep_density.setFirstInput(fluidfields)
keep_density.parm("group").set("@name==vel*")
keep_vel = refobject.createNode("blast", "keep_vel")
keep_vel.setFirstInput(fluidfields)
keep_vel.parm("group").set("@name==density")
# VOLUME VOP clamping density field below given treshold
density_treshold = keep_density.createOutputNode("volumevop",
"density_treshold")
vopglobals = density_treshold.node("volumevopglobal1")
treshold = density_treshold.createNode("parameter", "treshold")
treshold.parm("parmname").set("treshold")
treshold.parm("parmlabel").set("Treshold")
compare_density = density_treshold.createNode("compare", "compare_density")
compare_density.parm("cmp").set("gte")
compare_density.setInput(0, vopglobals, 1)
compare_density.setInput(1, treshold, 0)
twoway = compare_density.createOutputNode("twoway", "switch_density")
twoway.setInput(1, vopglobals, 1)
vop_output = density_treshold.node("volumevopoutput1")
vop_output.setFirstInput(twoway, 0)
density_treshold.setParmExpressions({"treshold": "ch(\"../treshold\")"})
# End of VOLUME VOP
scatter = refobject.createNode("scatter", "scatter")
scatter.setFirstInput(density_treshold)
scatter.parm("ptsperarea").set(1)
scatter.setParmExpressions({"nptsperarea": "ch(\"../nptsperarea\")"})
add_particles = scatter.createOutputNode("add", "add_particles")
add_particles.parm("addparticlesystem").set(1)
# VOP SOP adding velocity field to density-based pointcloud
add_vel = refobject.createNode("vopsop", "add_vel")
add_vel.parm("vex_numthreads").set(1)
add_vel.setFirstInput(add_particles)
add_vel.setInput(1, keep_vel, 0)
globals = add_vel.node("global1")
volumesamplex = add_vel.createNode("volumesample", "volumesample_x")
volumesamplex.setInput(2, globals, 0)
volumesamplex.parm("input_index").set(1)
volumesamplex.parm("primnum").set(0)
volumesampley = add_vel.createNode("volumesample", "volumesample_y")
volumesampley.setInput(2, globals, 0)
volumesampley.parm("input_index").set(1)
volumesampley.parm("primnum").set(1)
volumesamplez = add_vel.createNode("volumesample", "volumesample_z")
volumesamplez.setInput(2, globals, 0)
volumesamplez.parm("input_index").set(1)
volumesamplez.parm("primnum").set(2)
vel = volumesamplex.createOutputNode("floattovec", "vel")
vel.setInput(1, volumesampley, 0)
vel.setInput(2, volumesamplez, 0)
vel_by_fps = vel.createOutputNode("divconst", "vel_by_fps")
vel_by_fps.setParmExpressions({"divconst": "$FPS"})
add_vector = globals.createOutputNode("add", "add_vector")
add_vector.setNextInput(vel_by_fps, 0)
vex_output = add_vel.node("output1")
vex_output.setFirstInput(add_vector, 0)
# End of VOP SOP
merge1 = refobject.createNode("merge", "merge1")
merge1.setFirstInput(add_particles)
merge1.setInput(1, add_vel, 0)
bound = merge1.createOutputNode("bound", "bound")
# Box to switch from after first simulation frame
initial_box = refobject.createNode("box", "initial_box")
initial_box.setParmExpressions({
"sizex":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/sizex\")",
"sizey":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/sizey\")",
"sizez":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/sizez\")"
})
initial_box.setParmExpressions({
"tx":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/tx\")",
"ty":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/ty\")",
"tz":
"ch(\"" + initial_box.relativePathTo(fluidnode) + "/tz\")"
})
initial_switch = initial_box.createOutputNode("switch", "initial_switch")
initial_switch.setParmExpressions({
"input":
"$F>ch(\"" + initial_switch.relativePathTo(fluidnode) +
"/createframe\")",
})
initial_switch.setInput(1, bound, 0)
# Null to switch to if merging of simulation sources is disabled
no_active_source = refobject.createNode("null", "no_active_source")
merge_source = refobject.createNode("object_merge", "merge_source")
merge_source.setParmExpressions({
"numobj": "ch(\"../source_folder\")",
"xformtype": "ch(\"../xformtype\")"
})
merge_source.parm("xformpath").set("`chsop(\"../xformpath\")`")
numobj = merge_source.parm("numobj").eval()
source_switch = no_active_source.createOutputNode("switch",
"source_switch")
source_switch.setParmExpressions({"input": "ch(\"../source_activation\")"})
source_switch.setInput(1, merge_source, 0)
merge2 = initial_switch.createOutputNode("merge", "merge2")
merge2.setInput(1, source_switch, 0)
bound = merge2.createOutputNode("bound", "bound")
unroll_edges = bound.createOutputNode("ends", "unroll_edges")
unroll_edges.parm("closeu").set(4)
out = unroll_edges.createOutputNode("null", "OUT")
density_treshold.layoutChildren()
add_vel.layoutChildren()
refobject.layoutChildren()
out.setDisplayFlag(True)
out.setRenderFlag(True)
resize = resizeFluidToMatchSops(fluidnode, refobject)
resize.setCurrent(True, True)
sceneviewer.enterCurrentNodeState()
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()))',
script_callback_language=hou.scriptLanguage.Python, help="Intensity of pre-repair smoothing")
inputs_smooth_factor.setConditional(hou.parmCondType.DisableWhen, "{ isSmooth == 0 }")
inputs_folder.addParmTemplate(inputs_smooth_factor)
inputs_folder.addParmTemplate(hou.ButtonParmTemplate("new", "Full Reparation", script_callback = "hou.session.repair()", script_callback_language = hou.scriptLanguage.Python, help="Begin New Reparation"))
# Low Frequency Folder
low_folder = hou.FolderParmTemplate("low folder", "Low Frequency", folder_type = hou.folderType.Tabs)
low_alpha_beta = hou.FloatParmTemplate("low_alpha_beta", "Alpha:Beta",
1, default_value=(0.5,), min=0.0, max=1.0, min_is_strict=True, max_is_strict=True,
help="Used in normal correction. Try larger alpha for rounder output topologies, larger beta for flatter output topologies")
low_w1_w2 = hou.FloatParmTemplate("low_w1_w2", "w1:w2",
1, default_value=(0.5,), min=0.0, max=1.0, min_is_strict=True, max_is_strict=True,
help="Used in learning of optimized new point positions")
low_folder.addParmTemplate(low_alpha_beta)
