def _addVRayObjectPropertiesParmTemplates(ptg, vrayFolder):
ptg.appendToFolder(
vrayFolder,
hou.FolderParmTemplate(
"vray_object_properties_folder_main", "Main", **{
'parm_templates':
(vfh_ptg_utils.getParmTemplatesFromDS("vfh_object_properties")
),
'folder_type':
hou.folderType.Simple,
'tags': {
'spare_category': 'vray'
}
}))
ptg.appendToFolder(
vrayFolder,
hou.FolderParmTemplate(
"vray_object_properties_folder_wrapper", "Wrapper", **{
'parm_templates':
(vfh_ptg_utils.getParmTemplatesFromDS("MtlWrapper",
prefix="MtlWrapper")),
'folder_type':
hou.folderType.Simple,
'tags': {
'spare_category': 'vray'
}
}))
def add_shaders_folder(self, node):
"""
Add Shaders Tab to Mantra node.
"""
# parm_template_group
parm_template_group = node.parmTemplateGroup()
# check if folder already exists
if (parm_template_group.findFolder('Shaders')):
print('Shaders tab already exists. Not recreating.')
return
# folder_shaders
folder_shaders = hou.FolderParmTemplate(
"main5",
"Shaders",
folder_type=hou.folderType.Tabs,
default_value=0,
ends_tab_group=False)
# add folder to template group
parm_template_group.append(folder_shaders)
#set in node
node.setParmTemplateGroup(parm_template_group)
def addNoiseToSnippet(n,type,v = 1):
if n.parm('snippet') is not None:
includeAddSafe(n,'lzn')
ptg = n.parmTemplateGroup()
parm = ptg.findFolder('Noises')
if parm is None:
parm = hou.FolderParmTemplate('noises','Noises',folder_type = hou.folderType.Simple)
ptg.addParmTemplate(parm)
noise_id = len(parm.parmTemplates()) + 1
if type=="curl":
noise_folder = createCurlNoiseFolderParmTemplate(str(noise_id))
new_code = "vector4 pos{id} = set(@P,ch('o{id}'));\nvector n{id} = ch('a{id}')*curl(pos{id},ch('f{id}'),chi('t{id}'),ch('r{id}'),ch('at{id}'),chs('type{id}'),chs('sdf{id}'),chf('ef{id}'));\nv@vel = n1;".format(id = noise_id)
if type=="turb":
noise_folder = createTurbNoiseFolderParmTemplate(str(noise_id))
new_code = "vector n{id} = ch('a{id}')*turbv(v@P*chf('f{id}'),chi('t{id}'),ch('r{id}'),ch('at{id}'),chs('type{id}'));".format(id = noise_id)
if v==0:
new_code = "float n{id} = ch('a{id}')*turb(v@P*chf('f{id}'),chi('t{id}'),ch('r{id}'),ch('at{id}'),chs('type{id}'));".format(id = noise_id)
if type=="flow":
noise_folder = createFlowNoiseFolderParmTemplate(str(noise_id))
new_code = "vector4 pos{id} = set(@P*chf('f{id}'),ch('o{id}'));\nvector n{id} = ch('a{id}')*flowv(pos{id},chi('t{id}'),ch('r{id}'),ch('flow{id}'),ch('flowrate{id}'),ch('selfAdvect{id}'));".format(id = noise_id)
if v==0:
new_code = "vector4 pos{id} = set(@P*chf('f{id}'),ch('o{id}'));\nfloat n{id} = ch('a{id}')*flow(pos{id},chi('t{id}'),ch('r{id}'),ch('flow{id}'),ch('flowrate{id}'),ch('selfAdvect{id}'));".format(id = noise_id)
if type=="aa":
noise_folder = createAaNoiseFolderParmTemplate(str(noise_id))
new_code = "vector4 pos{id} = set(@P*chf('f{id}'),ch('o{id}'));\nvector n{id} = ch('a{id}')*aav(pos{id},chi('t{id}'),ch('r{id}'),chi('type{id}'));".format(id = noise_id)
if v==0:
new_code = "vector4 pos{id} = set(@P*chf('f{id}'),ch('o{id}'));\nfloat n{id} = ch('a{id}')*aa(pos{id},chi('t{id}'),ch('r{id}'),chi('type{id}'));".format(id = noise_id)
snippetAddCode(n,new_code)
ptg.appendToFolder(parm,noise_folder)
n.setParmTemplateGroup(ptg)
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_physical_camera_attributes():
if UI is None:
return
physCamDS = os.path.join(UI, "plugins", "CameraPhysical.ds")
if not os.path.exists(physCamDS):
sys.stderr.write("CameraPhysical.ds is not found!\n")
return
for node in hou.selectedNodes():
if node.type().name() not in {"cam"}:
continue
folderName = "V-Ray Physical Camera"
group = node.parmTemplateGroup()
if group.findFolder(folderName):
continue
sys.stdout.write("Adding \"Physical Camera\" attributes to \"%s\"...\n" % node.name())
folder = hou.FolderParmTemplate("VRayPhysicalCamera", folderName)
physCamGroup = hou.ParmTemplateGroup()
physCamGroup.setToDialogScript(open(physCamDS, 'r').read())
for parmTmpl in physCamGroup.parmTemplates():
folder.addParmTemplate(parmTmpl)
group.append(folder)
node.setParmTemplateGroup(group)
def parameters_ui(self):
# opening the template group
tg_parms = self.rig_subnet.parmTemplateGroup()
ch_p_folder_parms = hou.FolderParmTemplate(self.node.name()+"character_placer", "character_placer")
# creating the parms
for i in self.limb_subnet.children():
hou_parm_template = hou.FloatParmTemplate(i.name()+"_t", "Translate", 3, default_value=([0, 0, 0]),
min=0, max=10, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular,
naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.FloatParmTemplate(i.name()+"_r", "Rotate", 3, default_value=([0, 0, 0]), min=0,
max=360, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.FloatParmTemplate(i.name()+"_s", "Scale", 3, default_value=([1, 1, 1]), min=0,
max=10, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.FloatParmTemplate(i.name()+"_p", "Pivot", 3, default_value=([0, 0, 0]), min=0,
max=10, min_is_strict=False, max_is_strict=False,
look=hou.parmLook.Regular, naming_scheme=hou.parmNamingScheme.XYZW)
ch_p_folder_parms.addParmTemplate(hou_parm_template)
hou_parm_template = hou.SeparatorParmTemplate(i.name()+"_sep")
ch_p_folder_parms.addParmTemplate(hou_parm_template)
#finding the folder to put the parms and closing the template
folder_node = tg_parms.findFolder(["Rig Parms"])
tg_parms.appendToFolder(folder_node, ch_p_folder_parms)
self.rig_subnet.setParmTemplateGroup(tg_parms)
def _addVRayFolder(ptg):
vrayFolder = hou.FolderParmTemplate("vray_folder", VRAY_FOLDER)
vfh_attrs.insertInFolderAfterLastTab(ptg, ptg, vrayFolder)
vrayFolder = ptg.findFolder(VRAY_FOLDER)
vrayFolder.setName("vray_folder")
def Populate(kwargs, type='json'):
'''
type = 'xml', 'json'
'''
node = kwargs['node']
targetFolder = 'authorinfo'
# check for Author section
parms = node.parmTemplateGroup()
folder = parms.find(targetFolder)
if folder != None:
parms.remove(targetFolder)
# create and populate folder
folder = hou.FolderParmTemplate(targetFolder, 'Author', (),
hou.folderType.Simple, False)
if type == 'xml':
PopulateFromXML(kwargs, folder, 'author.xml')
elif type == 'json':
PopulateFromJSON(kwargs, folder, 'author.json')
parms.append(folder)
# add folder
node.setParmTemplateGroup(parms)
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 create_rop_parameters(script_args,
farm_name,
rop_node,
error_list_obj=None):
"""
Creates parameters on a specific ROP and farm
Args:
script_args (dict): The Houdini "kwargs" dictionary
farm_name (str): Name of the farm integration. Lowercase. Must match the name of the farm module. E.g. "deadline"
rop_node (hou.Node): A ROP node (in any context)
error_list_obj (RopErrorList): An instance of RopErrorList class to store any errors or warnings
Returns:
Bool: True if successful, False if the parameter configuration can't be found
"""
with ErrorList(error_list_obj) as error_list_obj:
param_list = get_config_parameter_list(farm_name, rop_node)
if param_list is None:
err_msg = "Could not load '{0}' ROP {1} parameters from config".format(
rop_node.type().name(), farm_name)
error_list_obj.add(ErrorMessage(err_msg))
return False
parm_list = create_parameters_from_list(param_list, farm_name)
farm_folder = hou.FolderParmTemplate("hf_{0}_folder".format(farm_name),
farm_name.title(), parm_list)
rop_parm_template_group = rop_node.parmTemplateGroup()
rop_parm_template_group.append(farm_folder)
rop_node.setParmTemplateGroup(rop_parm_template_group)
return True
def assign_preflight(self):
print "assign preflight node", self.node.path(
), "on topnet", self.parent
# get the template group for the parent top node.
self.parm_group = self.parent.parmTemplateGroup()
print "Create folder parm template"
self.parm_folder = hou.FolderParmTemplate("folder", "Firehawk")
self.parm_folder.addParmTemplate(
hou.StringParmTemplate(
"preflight_node",
"Preflight Node",
1, [""],
string_type=hou.stringParmType.NodeReference))
# Search for the template folder. if it already exists it will be replaced in order to ensure parms are current.
self.found_folder = self.parm_group.findFolder("Firehawk")
print "self.found_folder", self.found_folder
# If a folder already exists on the node, remove it and add it again. This deals with any changes to the parm layout if they occur.
if self.found_folder:
self.parm_group.remove(self.found_folder)
# re add the folder to the template group.
self.parm_group.append(self.parm_folder)
# update the parm template on the parent node.
self.parent.setParmTemplateGroup(self.parm_group)
# set values for path to preflight node.
self.parent.parm("preflight_node").set(self.node.path())
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 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 create_cook_button(geo):
script='''
try:
hou.node("./set_rig_alembic").cook(force=True)
except:
print "Error while cooking set_rig_alembic"
try:
hou.node("./set_model_alembic").cook(force=True)
except:
print "Error while cooking set_model_alembic"
try:
hou.node("./animated_rig").cook(force=True)
except:
print "Error while cooking animated_rig"
try:
hou.node("./animated_model").cook(force=True)
except:
print "Error while cooking animated_model"
try:
hou.node("./set_switch").cook(force=True)
except:
print "Error while cooking set_switch"
try:
hou.node("./shot_switch").cook(force=True)
except:
print "Error while cooking shot_switch"
'''
hou_parm_template_group = geo.parmTemplateGroup()
cook = hou.ButtonParmTemplate('cook', 'Refresh', script_callback=script, script_callback_language=hou.scriptLanguage.Python)
trouble_shoot_folder = hou.FolderParmTemplate('trouble_shoot', 'Trouble Shooting', folder_type=hou.folderType.Tabs)
trouble_shoot_folder.addParmTemplate(cook)
hou_parm_template_group.append(trouble_shoot_folder)
geo.setParmTemplateGroup(hou_parm_template_group)
return geo
def _addVRayHairFolder(ptg):
vrayFolder = ptg.findFolder(VRAY_FOLDER)
assert vrayFolder
hairFolder = hou.FolderParmTemplate("vray_hair_folder_main", "Hair")
vfh_ptg_utils.insertInFolderAfterLastTab(ptg, vrayFolder, hairFolder)
def add_physical_camera_attributes():
physCamPlugID = 'CameraPhysical'
CameraPhysicalDesc = vfh_json.getPluginDesc(physCamPlugID)
if not CameraPhysicalDesc:
sys.stderr.write("CameraPhysical plugin description is not found!\n")
else:
physCamTabName = "V-Ray Physical Camera"
for node in hou.selectedNodes():
if node.type().name() == "cam":
sys.stdout.write(
"Adding \"Physical Camera\" attributes to \"%s\"...\n" %
node.name())
ptg = node.parmTemplateGroup()
if not ptg.findFolder(physCamTabName):
vfh_attrs.insertInFolderAfterLastTab(
ptg, ptg,
hou.FolderParmTemplate("vray.%s" % physCamPlugID,
physCamTabName))
vfh_attrs.addPluginParms(ptg,
CameraPhysicalDesc,
parmPrefix=physCamPlugID,
parmFolder=physCamTabName)
node.setParmTemplateGroup(ptg)
# Set "Use" by default.
node.parm("CameraPhysical_use").set(True)
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 pywy():
"""
create a node to test code with python
"""
help(pywy)
import hou
nodeSelect = hou.selectedNodes()
pink = hou.Color((0.98, 0.275, 0.275))
for node in nodeSelect:
#create node from selected node
pyNull = node.createOutputNode("null", "pythonRunCode")
pyNull.setColor(pink)
#prepa param
parm_group = pyNull.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate("folder", "pywy")
#button run code
button = hou.ButtonParmTemplate("runcode", "Run_Code")
button.setTags({
"script_callback_language":
"python",
"script_callback":
"exec(kwargs['node'].parm('pythonCode').eval())"
})
parm_folder.addParmTemplate(button)
#multistring
multistring = hou.StringParmTemplate("pythonCode", "PythonCode", 1)
multistring.setTags({"editor": "1", "editorlang": "python"})
parm_folder.addParmTemplate(multistring)
#append param
parm_group.append(parm_folder)
pyNull.setParmTemplateGroup(parm_group)
def _addVRayObjectPropertiesFolder(ptg):
vrayFolder = ptg.findFolder(VRAY_FOLDER)
assert vrayFolder
obPropFolder = hou.FolderParmTemplate("vray_object_properties_folder_main",
"Object Properties")
vfh_ptg_utils.insertInFolderAfterLastTab(ptg, vrayFolder, obPropFolder)
def _addVRayDisplacementFolder(ptg):
vrayFolder = ptg.findFolder(VRAY_FOLDER)
assert vrayFolder
dispFolder = hou.FolderParmTemplate("vray_displ_folder_main",
"Displacement")
vfh_ptg_utils.insertInFolderAfterLastTab(ptg, vrayFolder, dispFolder)
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 createFolder(ptg, address):
"""create a folder in the given parm template group at the address specified
This function accepts either a tuple of folder labels or a string using '/' to separate the folder names:
createFolder(ptg, 'Top/Middle/Bottom')
This function returns both the modified parm template group and the newly created folder parm template"""
if isinstance(address, str):
address = address.split("/")
_address = address
if ptg.findFolder(_address):
return ptg, ptg.findFolder(address)
target = ptg
i = 1
while ptg.findFolder(_address[:i]):
target = ptg.findFolder(_address[:i])
i += 1
temp = hou.FolderParmTemplate(_address[-1].lower(), _address[-1])
_address = _address[i - 1:-1]
target_clone = None
if isinstance(target, hou.FolderParmTemplate):
target_clone = target.clone()
for f in _address[::-1]:
n = hou.FolderParmTemplate(f.lower(), f)
n.addParmTemplate(temp)
temp = n
if target_clone:
target_clone.addParmTemplate(temp)
ptg.replace(target, target_clone)
else:
ptg.addParmTemplate(temp)
return ptg, ptg.findFolder(address)
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 add_physical_camera_attributes():
if UI is None:
return
physCamDS = os.path.join(UI, "plugins", "CameraPhysical.ds")
if not os.path.exists(physCamDS):
sys.stderr.write("CameraPhysical.ds is not found!\n")
return
for node in hou.selectedNodes():
if node.type().name() not in {"cam"}:
continue
folderName = "VfhCameraPhysical"
folderLabel = "V-Ray Physical Camera"
currentSettings = _getCurrectSettings(node)
_removeCameraPhysicalAttributes(node, folderLabel)
group = node.parmTemplateGroup()
folder = hou.FolderParmTemplate(folderName, folderLabel)
physCamGroup = hou.ParmTemplateGroup()
physCamGroup.setToDialogScript(open(physCamDS, 'r').read())
for parmTmpl in physCamGroup.parmTemplates():
folder.addParmTemplate(parmTmpl)
group.append(folder)
node.setParmTemplateGroup(group)
for parm in node.parms():
try:
attrName = parm.name()
parmValue = currentSettings.get(attrName, None)
if parmValue is not None:
parm.set(parmValue)
elif attrName in {"CameraPhysical_f_number"}:
parm.setExpression("ch(\"./fstop\")")
elif attrName in {"CameraPhysical_focus_distance"}:
parm.setExpression("ch(\"./focus\")")
elif attrName in {"CameraPhysical_horizontal_offset"}:
parm.setExpression("-ch(\"./winx\")")
elif attrName in {"CameraPhysical_vertical_offset"}:
parm.setExpression("-ch(\"./winy\")")
elif attrName in {"CameraPhysical_focal_length"}:
parm.setExpression("ch(\"./focal\")")
elif attrName in {"CameraPhysical_film_width"}:
parm.setExpression("ch(\"./aperture\")")
except:
pass
def ghostShaderCreate(self, ghost_mat_folder, ghost_name):
"""Create a shader for a new ghost.
INPUTS:
ghost_mat_folder -- ghost shader network folder
ghost_name -- object name from which a new ghost is created
OUTPUTS:
ghost_shader -- new ghost shader node
"""
with hou.undos.group("Create Ghost Shader"):
current_frame = hou.frame()
ghost_shader = ghost_mat_folder.createNode(
'vopmaterial',
node_name=ghost_name + "_ghost_mat" + '_frame_' +
str(current_frame))
parm_group = ghost_shader.parmTemplateGroup()
parm_folder = hou.FolderParmTemplate("folder", "OpenGL")
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_spec", "Specular", 3))
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_transparency", "Transparency", 1))
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_ior", "IOR", 1))
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_spec_intensity", "Intensity", 1))
parm_folder.addParmTemplate(
hou.FloatParmTemplate("ogl_rough", "Roughness", 1))
parm_group.append(parm_folder)
ghost_shader.setParmTemplateGroup(parm_group)
ghost_shader.setParms({
"ogl_specx":
self.ghostColorLabel.palette().color(
QtGui.QPalette.Base).redF(),
"ogl_specy":
self.ghostColorLabel.palette().color(
QtGui.QPalette.Base).greenF(),
"ogl_specz":
self.ghostColorLabel.palette().color(
QtGui.QPalette.Base).blueF(),
"ogl_transparency":
1,
"ogl_ior":
1.06,
"ogl_spec_intensity":
5,
"ogl_rough":
0
})
ghost_shader.moveToGoodPosition()
return ghost_shader
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 _addVRayCameraPhysical(ptg):
vrayFolder = ptg.findFolder(VRAY_FOLDER)
assert vrayFolder
vfh_ptg_utils.insertInFolderAfterLastTab(
ptg, vrayFolder,
hou.FolderParmTemplate(
"VfhCameraPhysicalTab", "Physical Camera", **{
'parm_templates': (vfh_ptg_utils.getParmTemplatesFromDS(
"CameraPhysical", prefix="CameraPhysical")),
'tags': {
'spare_category': 'vray'
}
}))
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 add_parm(node):
ptg = node.parmTemplateGroup()
if ptg.parmTemplates()[-1].name() == 'wedge_list':
for i in ptg.parmTemplates()[-1].parmTemplates():
node.parm(i.name()).set(10)
else:
parm_folder = hou.FolderParmTemplate('wedge_list', 'Wedge List')
parm_folder.setFolderType(hou.folderType.Simple)
parm_folder.addParmTemplate(hou.FloatParmTemplate('first', 'First', 1))
parm_folder.addParmTemplate(hou.FloatParmTemplate('last', 'Last', 1))
ptg.append(parm_folder)
node.setParmTemplateGroup(ptg)
def _addVRayHairParmTemplates(ptg, vrayFolder):
ptg.appendToFolder(
vrayFolder,
hou.FolderParmTemplate(
"vray_hair_folder_main", "Hair", **{
'parm_templates':
(vfh_ptg_utils.getParmTemplatesFromDS("GeomMayaHair",
prefix="GeomMayaHair")),
'folder_type':
hou.folderType.Simple,
'tags': {
'spare_category': 'vray'
}
}))
