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 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 add_TMP(self, attr_name, attr_size, tmp_type, current_tmpparm):
attr_label = attr_name
if tmp_type == "RampParmTemplate":
current_tmpparm.append(
hou.RampParmTemplate(attr_name,
attr_label,
hou.rampParmType.Float,
default_value=1,
default_basis=None,
color_type=None))
elif tmp_type == "ButtonParmTemplate" or tmp_type == "FolderParmTemplate" or tmp_type == "LabelParmTemplate" or tmp_type == "ToggleParmTemplate":
parm = partial(getattr(hou, tmp_type),
name=attr_name,
label=attr_label)
current_tmpparm.append(parm())
elif tmp_type == "SeparatorParmTemplate":
parm = partial(getattr(hou, tmp_type), name=attr_name)
current_tmpparm.append(parm())
else:
parm = partial(getattr(hou, tmp_type),
name=attr_name,
label=attr_label,
num_components=attr_size)
current_tmpparm.append(parm())
return current_tmpparm
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 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 createSpareParms(node):
mode = node.parm("mode").eval()
clear = node.parm("clearchans").eval()
parmname = "snippet%s" % (int(mode) + 1)
code = node.parm(parmname).unexpandedString()
code = _remove_comments(code)
chcalls = ['ch', 'chf', 'chi', 'chv', 'chp', 'ch3', 'ch4', 'chramp', 'chs']
ch_to_size = {
'ch': 1,
'chf': 1,
'chi': 1,
'chv': 3,
'chp': 4,
'ch3': 9,
'ch4': 16,
'chramp': 1,
'chs': 1
}
chmatches = []
createdParms = []
for chcall in chcalls:
matches = re.findall(chcall + ' *\( *"(\w+)" *[\),]', code)
matches += re.findall(chcall + " *\( *'(\w+)' *[\),]", code)
for match in matches:
chmatches.append(match)
for match in matches:
if (node.parm(match) is None) and (node.parmTuple(match) is None):
# No match, add the parameter.
template = None
tuplesize = ch_to_size[chcall]
label = match.title().replace('_', ' ')
if chcall == 'chramp':
# Unfortunately we can't tell colour from scalar ramps here.
template = hou.RampParmTemplate(match, label,
hou.rampParmType.Float)
elif chcall == 'chs':
template = hou.StringParmTemplate(match, label, tuplesize)
elif chcall == 'chi':
template = hou.IntParmTemplate(match, label, tuplesize)
else:
# Range is less meaningfull for tuples, so set it nicely for scalars.
template = hou.FloatParmTemplate(match,
label,
tuplesize,
min=0,
max=1)
if not node.parmTemplateGroup().findFolder("Channels"):
node.addSpareParmTuple(
hou.FolderParmTemplate(
"channels",
"Channels",
folder_type=hou.folderType.Simple))
node.addSpareParmTuple(template, in_folder=("Channels", ))
if template.name() == "fps":
node.parm("fps").setExpression("$FPS")
if clear:
folder = node.parmTemplateGroup().findFolder("Channels")
if folder:
for parmtemplate in folder.parmTemplates():
if not parmtemplate.name() in chmatches:
node.removeSpareParmTuple(parmtemplate)
code = node.parm(parmname).unexpandedString()
node.parm(parmname).set(code)
def promote_parm_to_ui(parm_to_add, node_to_put_the_parm, in_this_folder=None, insert_before_parm=None,
insert_after_parm=None, parm_name=None, parm_label=None, ch_link=True, join_with_next_parm=False,
minimum=None, maximum=None):
"""
parm_to_add = is the parameter from the ui that we want to promote
node_to_put_the_parm = the node where we want to send the parameter
in_this_folder = will put it in that folder tuple of folders ["bla", "ble"]
insertBefore_parm = will put the created parameter before this parm
insertAfter_parm = will put the created parameter after this parm
in case the parms all ready exist or the user want another name
parm_name = the internal name fo the parm
parm_label = how the name is display in the ui
ch_link = channel link, will create the link reference between promoted parm and original parm.
join_with_next_parm if put the parm in the same line or not.
"""
try:
parm_to_add_template = parm_to_add.parmTemplate()
except:
print "make sure you are passing a parameter, and not a node or a class"
#print type(parm_to_add_template), parm_to_add_template.name()
if type(parm_to_add) == hou.Parm:
if type(parm_to_add_template) == hou.RampParmTemplate:
# if the parameter is a ramp
ramp_parm_values = parm_to_add.evalAsRamp()
ori_name = parm_to_add.name()
ori_label = parm_to_add.description()
parm_to_add_template = hou.RampParmTemplate(ori_name, ori_label, hou.rampParmType.Float,show_controls=False)
elif type(parm_to_add_template) == hou.StringParmTemplate:
parm_to_add_template.setDefaultValue(parm_to_add.evalAsString())
else:
try:
parm_to_add_template.setDefaultValue([parm_to_add.eval()])
except:
parm_to_add_template.setDefaultValue(parm_to_add.eval())
elif type(parm_to_add) == hou.ParmTuple:
parm_to_add_template.setDefaultValue(parm_to_add.eval())
if join_with_next_parm is True:
parm_to_add_template.setJoinWithNext(True)
if parm_name is not None:
parm_to_add_template.setName(parm_name)
if parm_label is not None:
parm_to_add_template.setLabel(parm_label)
if minimum is not None:
parm_to_add_template.setMinValue(minimum)
if maximum is not None:
parm_to_add_template.setMaxValue(maximum)
if in_this_folder is not None:
ui_folder(node_to_put_the_parm, in_this_folder)
parm_to_ui(node_to_put_the_parm, parm_to_add_template, in_this_folder=in_this_folder, insert_before_parm=insert_before_parm, insert_after_parm=insert_after_parm)
# here we link the parameter
if ch_link is True:
if type(parm_to_add) == hou.Parm:
# if the parameter is a ramp
if type(parm_to_add_template) == hou.RampParmTemplate:
tg = node_to_put_the_parm.parmTemplateGroup()
parm_found = tg.find(parm_to_add_template.name() )
rel_path = node_to_put_the_parm.relativePathTo(parm_to_add.node())
parm_found.setScriptCallback("hou.pwd().node('%s').parm('%s').set(hou.pwd().parm('%s').evalAsRamp())" % ( rel_path, parm_to_add_template.name(), parm_to_add_template.name() ) )
parm_found.setScriptCallbackLanguage(hou.scriptLanguage.Python)
tg.replace(parm_to_add_template.name(), parm_found)
node_to_put_the_parm.setParmTemplateGroup(tg)
if parm_name is None:
node_to_put_the_parm.parm(ori_name).set(ramp_parm_values)
if parm_name is not None:
node_to_put_the_parm.parm(parm_name).set(ramp_parm_values)
else:
parm_to_add.set(node_to_put_the_parm.parm( parm_to_add_template.name()))
parm_to_add.pressButton()
elif type(parm_to_add) == hou.ParmTuple:
parm_to_add_length = parm_to_add_template.numComponents()
if parm_to_add_length > 1:
if str(parm_to_add.parmTemplate().namingScheme()) == "parmNamingScheme.XYZW":
cord = ["x", "y", "z", "w"]
for i in range(0, parm_to_add_length):
parm_to_add[i].set(node_to_put_the_parm.parm(parm_to_add_template.name() + cord[i]))
else:
for i in range(0, parm_to_add_length):
parm_name = parm_to_add_template.name()+str(i+1)
parm_to_add[i].set(node_to_put_the_parm.parm(parm_name) )
for i in range(0, parm_to_add_length):
parm_to_add[i].pressButton()
def add_shutter_shape_property(self, node):
"""
Add vm_shuttershape property to mantra node and adjust it. This property maps
the shutter open/close speed of the camera.
"""
# Create Parameters
#------------------------------------------------------------------
# parm_group
parm_group = node.parmTemplateGroup()
# folder_sampling
folder_sampling = parm_group.containingFolder('allowmotionblur')
# vm_shuttershape
hou_parm_template = hou.RampParmTemplate("vm_shuttershape",
"Shutter Shape",
hou.rampParmType.Float,
default_value=2,
default_basis=None,
color_type=None)
hou_parm_template.setConditional(
hou.parmCondType.DisableWhen,
"{ allowmotionblur == 0 } { vm_renderengine == micropoly } { vm_renderengine == pbrmicropoly }"
)
hou_parm_template.setHelp(
"Controls the opening of the shutter along shutter time through a grayscale ramp. The higher the ramp value at a given time point, the more time sample will be focused in that area. Note that the ramp is always evaluated across the entire range, regardless of the shutter time setting."
)
hou_parm_template.setTags({
"rampfloatdefault":
"1pos 0 1value 1 1interp catmull-rom 2pos 1 2value 1 2interp catmull-rom",
"spare_category": "Sampling"
})
# append
parm_group.appendToFolder(folder_sampling, hou_parm_template)
# set in node
node.setParmTemplateGroup(parm_group)
# log
parm = node.parm("vm_shuttershape")
parm_name = parm.name()
parm_value = parm.eval()
print('Added parm. {0} - {1}'.format(parm_name, parm_value))
# Adjust Parameters
#------------------------------------------------------------------
# vm_shuttershape
parm = node.parm("vm_shuttershape")
parm.lock(False)
parm.set(8)
parm.setAutoscope(False)
# vm_shuttershape1pos
parm = node.parm("vm_shuttershape1pos")
parm.lock(False)
parm.set(0)
parm.setAutoscope(False)
# vm_shuttershape1value
parm = node.parm("vm_shuttershape1value")
parm.lock(False)
parm.set(0)
parm.setAutoscope(False)
# vm_shuttershape1interp
parm = node.parm("vm_shuttershape1interp")
parm.lock(False)
parm.set("linear")
parm.setAutoscope(False)
# vm_shuttershape2pos
parm = node.parm("vm_shuttershape2pos")
parm.lock(False)
parm.set(0.125)
parm.setAutoscope(False)
# vm_shuttershape2value
parm = node.parm("vm_shuttershape2value")
parm.lock(False)
parm.set(0.65174126625061035)
parm.setAutoscope(False)
# vm_shuttershape2interp
parm = node.parm("vm_shuttershape2interp")
parm.lock(False)
parm.set("monotonecubic")
parm.setAutoscope(False)
# vm_shuttershape3pos
parm = node.parm("vm_shuttershape3pos")
parm.lock(False)
parm.set(0.40000000596046448)
parm.setAutoscope(False)
# vm_shuttershape3value
parm = node.parm("vm_shuttershape3value")
parm.lock(False)
parm.set(1)
parm.setAutoscope(False)
# vm_shuttershape3interp
parm = node.parm("vm_shuttershape3interp")
parm.lock(False)
parm.set("catmull-rom")
parm.setAutoscope(False)
# vm_shuttershape4pos
parm = node.parm("vm_shuttershape4pos")
parm.lock(False)
parm.set(0.64999997615814209)
parm.setAutoscope(False)
# vm_shuttershape4value
parm = node.parm("vm_shuttershape4value")
parm.lock(False)
parm.set(1)
parm.setAutoscope(False)
# vm_shuttershape4interp
parm = node.parm("vm_shuttershape4interp")
parm.lock(False)
parm.set("catmull-rom")
parm.setAutoscope(False)
# vm_shuttershape5pos
parm = node.parm("vm_shuttershape5pos")
parm.lock(False)
parm.set(0.69999998807907104)
parm.setAutoscope(False)
# vm_shuttershape5value
parm = node.parm("vm_shuttershape5value")
parm.lock(False)
parm.set(0.74129354953765869)
parm.setAutoscope(False)
# vm_shuttershape5interp
parm = node.parm("vm_shuttershape5interp")
parm.lock(False)
parm.set("catmull-rom")
parm.setAutoscope(False)
# vm_shuttershape6pos
parm = node.parm("vm_shuttershape6pos")
parm.lock(False)
parm.set(0.80000001192092896)
parm.setAutoscope(False)
# vm_shuttershape6value
parm = node.parm("vm_shuttershape6value")
parm.lock(False)
parm.set(0.42506229877471924)
parm.setAutoscope(False)
# vm_shuttershape6interp
parm = node.parm("vm_shuttershape6interp")
parm.lock(False)
parm.set("catmull-rom")
parm.setAutoscope(False)
# vm_shuttershape7pos
parm = node.parm("vm_shuttershape7pos")
parm.lock(False)
parm.set(0.89999997615814209)
parm.setAutoscope(False)
# vm_shuttershape7value
parm = node.parm("vm_shuttershape7value")
parm.lock(False)
parm.set(0.1840796023607254)
parm.setAutoscope(False)
# vm_shuttershape7interp
parm = node.parm("vm_shuttershape7interp")
parm.lock(False)
parm.set("catmull-rom")
parm.setAutoscope(False)
# vm_shuttershape8pos
parm = node.parm("vm_shuttershape8pos")
parm.lock(False)
parm.set(1)
parm.setAutoscope(False)
# vm_shuttershape8value
parm = node.parm("vm_shuttershape8value")
parm.lock(False)
parm.set(0)
parm.setAutoscope(False)
# vm_shuttershape8interp
parm = node.parm("vm_shuttershape8interp")
parm.lock(False)
parm.set("catmull-rom")
parm.setAutoscope(False)
