def nullMerge():
'''
create a null and a merge node just after, for lazy lazy man.
'''
help(nullMerge)
import hou
obj = hou.node("/obj")
nodeSelect = hou.selectedNodes()
pink = hou.Color((0.98, 0.275, 0.275))
black = hou.Color((0, 0, 0))
for node in nodeSelect:
nullName = node.name()
myNull = node.createOutputNode("null", nullName.upper())
myNull.setPosition(node.position())
myNull.move([0, -.75])
myNull.setColor(black)
parent = myNull.parent()
parentName = parent.name()
myNullName = node.name()
pos = myNull.position()
print parentName + myNullName
myMerge = parent.createNode("object_merge",
nullName.upper() + "_MERGE")
myMerge.setParms(
{'objpath1': "/obj/" + parentName + "/" + myNullName.upper()})
myMerge.setPosition(pos)
def createSubnet():
node = checkSelection()
if node:
sel = hou.selectedNodes()
if len(sel) == 1 and node.type().name() == 'subnet':
pat = re.compile('label\d')
for p in node.parms():
find = pat.search(p.name())
if find:
p.hide(1)
node.setColor(hou.Color(colors.subnet))
return
parent = node.parent()
pos = node.position()
sub = parent.createNode("subnet")
sub.setPosition(pos + hou.Vector2(0, -1))
sub.setInput(0, node)
sub.setDisplayFlag(1)
sub.setRenderFlag(1)
sparms = sub.parms()
for p in sparms:
p.hide(1)
innull = sub.createNode('null', node_name='IN')
innull.setInput(0, sub.indirectInputs()[0])
innull.setPosition(hou.Vector2(0, 5))
out = sub.createNode('output', node_name='output0')
out.setInput(0, innull)
sub.setColor(hou.Color(colors.subnet))
out.setColor(hou.Color(colors.output))
node.setSelected(0)
sub.setSelected(1)
def objGeom(network, ctx, filename):
if not matchTypes(GEO_EXTENSIONS).search(filename):
return
name, ext = baseName(filename, GEO_EXTENSIONS)
if ext == '.fbx':
hou.hipFile.importFBX(filename)
return
if ext == '.ass':
procedural = ctx.createNode('arnold_procedural',
node_name=name.title())
procedural.setPosition(position)
procedural.parm('ar_filename').set(filename)
return
geo = ctx.createNode('geo', node_name=name.title())
geo.setPosition(position)
for child in geo.children():
child.destroy()
if ext == '.abc':
alembic = geo.createNode('alembic', node_name='Import_Alembic')
geo.setColor(hou.Color(ALEMBIC_NODE_COLOR))
alembic.parm('fileName').set(filename)
else:
geometry = geo.createNode('file', node_name='Import_Geometry')
geo.setColor(hou.Color(GEO_NODE_COLOR))
geometry.parm('file').set(filename)
def create_sop_exporter(self):
# process out node
self.out_node.setColor(hou.Color((0.9, 0.4, 0)))
self.out_node.setUserData('nodeshape', 'bulge')
# create exporter hda
self.sop_exporter_node = self.parent.createNode(
'exporter', self.sop_hda_name)
self.sop_exporter_node.setPosition(self.out_node.position() +
hou.Vector2([0, -1.3]))
self.sop_exporter_node.setInput(0, self.out_node)
self.sop_exporter_node.setColor(hou.Color((0, 0, 0)))
# process cache node
self.cache_node = hou.node(self.out_node.name().replace(
'OUT_', 'CACHE_'))
if self.cache_node is None:
self.cache_node = self.parent.createNode(
'null',
self.out_node.name().replace('OUT_', 'CACHE_'))
self.cache_node.setPosition(self.sop_exporter_node.position() +
hou.Vector2([0, -1.3]))
self.cache_node.setInput(0, self.sop_exporter_node)
self.out_node_connexion_transfer()
else:
if self.cache_node.inputs in [(self.out_node, ), ()]:
self.cache_node.setInput(0, self.sop_exporter_node)
self.out_node_connexion_transfer()
else:
pass # node has been connected to another node, skip
self.cache_node.setColor(hou.Color((0.9, 0.4, 0)))
self.cache_node.setUserData('nodeshape', 'bulge_down')
def create_rootSubnet(context, fixINode, fixIParentPath, fixINodePos,
projectSettings):
""" set the fix import node display """
color = fixINode.setColor(hou.Color((0.6, 1.0, 0.6)))
try:
fixINode.setName(projectSettings)
except:
pass
""" set the fix import node display """
root = hou.node(fixIParentPath).createNode(remapRootNode, remapRoot, 1)
root.setPosition(hou.Vector2(fixINodePos[0], fixINodePos[1] - 1.5))
color = root.setColor(hou.Color((1, 0.96, 0.45)))
root.setInput(0, fixINode, 0)
""" create subnet transform node """
transform = hou.node(root.path()).createNode(remapRootNode, remapTransform,
1)
subnetOutput = root.indirectInputs()
transform.setInput(0, subnetOutput[0])
color = transform.setColor(hou.Color((1, 0.96, 0.45)))
""" apply sceneScale scale to root """
fixImportNodeName = fixINode.name()
root.parm('tx').lock(1)
root.parm('ty').lock(1)
root.parm('tz').lock(1)
root.parm('rx').lock(1)
root.parm('ry').lock(1)
root.parm('rz').lock(1)
root.parm('sx').lock(1)
root.parm('sy').lock(1)
root.parm('sz').lock(1)
root.parm('px').lock(1)
root.parm('py').lock(1)
root.parm('pz').lock(1)
root.parm('scale').setExpression('ch("../' + fixImportNodeName +
'/global_scale")')
""" apply scene transform to transform """
fixImportNodeName = fixINode.name()
transform.parm('tx').setExpression('ch("../../' + fixImportNodeName +
'/translatex")')
transform.parm('ty').setExpression('ch("../../' + fixImportNodeName +
'/translatey")')
transform.parm('tz').setExpression('ch("../../' + fixImportNodeName +
'/translatez")')
transform.parm('rx').setExpression('ch("../../' + fixImportNodeName +
'/rotatex")')
transform.parm('ry').setExpression('ch("../../' + fixImportNodeName +
'/rotatey")')
transform.parm('rz').setExpression('ch("../../' + fixImportNodeName +
'/rotatez")')
transform.parm('sx').lock(1)
transform.parm('sy').lock(1)
transform.parm('sz').lock(1)
transform.parm('px').lock(1)
transform.parm('py').lock(1)
transform.parm('pz').lock(1)
transform.parm('scale').lock(1)
return transform
def run():
# Set Context
obj = hou.node("/obj")
##########################
# Frustum
##########################
try:
frust = obj.createNode("qLib::camera_frustrum_ql")
except:
hou.ui.displayMessage("Please install qlib first")
return
##########################
# Cam
##########################
myCam = obj.createNode("cam")
myCam.parm('resx').set('1920')
myCam.parm('resy').set('1080')
myCam.parm('near').set('0.01')
# Connect Camera
frust.parm('camera').set(myCam.path())
# Set Parms
frust.parm('near').set('0.1')
frust.parm('far').set('30')
frust.parm('renderable').set('0')
##########################
# Rig
##########################
rig = obj.createNode('qLib::camera_rig_ql')
# SetParent
myCam.setInput(0, rig, 0)
##########################
# NetworkBox
##########################
nBox = obj.createNetworkBox()
# AddItems
nBox.addItem(rig)
nBox.addItem(myCam)
nBox.addItem(frust)
nBox.setComment('Camera')
# LayoutNodes
rig.moveToGoodPosition()
myCam.moveToGoodPosition()
frust.moveToGoodPosition()
# Color
rig.setColor(hou.Color((0, 0.7, 0.5)))
myCam.setColor(hou.Color((0, 0.7, 0.5)))
frust.setColor(hou.Color((0, 0.7, 0.5)))
# SetPickingFlags
myCam.parm('picking').set('0')
frust.parm('picking').set('0')
def colorize_op(kwargs):
'''.'''
# node type names and default colors
#
cs = {
'cam': (0.5, 0.5, 0.5),
'geo': (0.6, 0.6, 0.6),
'hlight': (1.0, 1.0, 0.8),
'indirectlight': (1.0, 1.0, 0.6),
'instance': (1.0, 0.8, 0.8),
'shopnet': (1.0, 1.0, 0.8),
'material': (0.6, 0.6, 1.0),
'cache': (0.0, 0.0, 0.0),
'object_merge': (0.8, 1.0, 0.8),
'dopnet': (0.8, 0.8, 1.0),
'ropnet': (0.2, 0.0, 0.4),
'rop_geometry': (0.2, 0.0, 0.4),
'rop_alembic': (0.2, 0.0, 0.4),
'edit': (1.0, 0.8, 0.8),
'explodedview': (0.0, 0.4, 1.0),
'visualize': (0.0, 0.4, 1.0),
'ifd': (0.8, 0.8, 1.0),
'oceansource': (1.0, 1.0, 1.0),
'whitewatersource': (1.0, 1.0, 1.0),
'lastone': (0, 0, 0)
}
# list of nodes to be created as bypassed by default
#
bypass = ['cache', 'lastone']
try:
N = kwargs['node']
n = kwargs['node'].name()
t = kwargs['type'].name()
dbg('node=%s type=%s' % (
n,
t,
))
# set all solver nodes to white
#
if 'solver' in t.lower():
N.setColor(hou.Color((1, 1, 1)))
# set node types to certain colors
#
if t in cs:
N.setColor(hou.Color(cs[t]))
# bypass some node types by default
#
if t in bypass:
N.bypass(True)
except:
pass # ignore errors silently
def setNodeColor(applicationObject='', latest=True):
latestColor = hou.Color(hou.Vector3(0.07, 0.63, 0.29))
oldColor = hou.Color(hou.Vector3(0.89, 0.39, 0.08))
for n in hou.node('/').allSubChildren():
if n.name() == applicationObject:
if latest:
n.setColor(latestColor)
else:
n.setColor(oldColor)
def check_seq(self, node):
path = self._compute_output_path(node)
node_color = hou.Color((0, 0.8, 0))
return_str = None
if '$F4' in path:
path = path.replace('$F4', '*')
sequences = pyseq.get_sequences(path)
if len(sequences) == 1:
seq = sequences[0]
if seq:
if seq.missing():
return_str = '[%s-%s], missing %s' % (seq.format('%s'),
seq.format('%e'),
seq.format('%M'))
else:
return_str = seq.format('%R')
node_color = hou.Color((0.8, 0, 0))
else:
return_str = 'Invalid Sequence Object!'
else:
return_str = 'No or multiple sequences detected!'
elif path.split('.')[-1] == 'abc':
if os.path.exists(path):
abcRange = abc.alembicTimeRange(path)
if abcRange:
return_str = '[%s-%s] - ABC Archive' % (int(
abcRange[0] * hou.fps()), int(abcRange[1] * hou.fps()))
else:
return_str = 'Single Abc'
node_color = hou.Color((0.8, 0, 0))
else:
return_str = 'No Cache!'
else:
if os.path.exists(path):
return_str = 'Single Frame'
node_color = hou.Color((0.8, 0, 0))
else:
return_str = 'No Cache!'
# update shotgun files node as well
for file_node in node.dependents(include_children=False):
if file_node.type().name() == 'sgtk_file' and file_node.parm(
'mode').evalAsString() == 'out' and file_node.parm(
'rop').evalAsString() == node.path(
) and file_node.parm('overver').evalAsInt() == 0:
file_node.parm('seqlabel').set(return_str)
node.setColor(node_color)
node.parm('seqlabel').set(return_str)
def update(self):
gobj=self.gameObject()
bbx=gobj.getComponent("BaseColliderComponent")
objs=[x for x in gobj.findObjects(".*") if x is not gobj]
node=gobj.getComponent("ShapeComponent").getHouNode()
clr=hou.Color(1,1,1)
for obj in objs:
if bbx.collidesWith(obj):
clr=hou.Color(1,0,0)
break
node.setColor(clr)
def create_snippet_network(self):
"""Create snippet subnetwork at /obj level for user selection."""
selection = utils_hou.get_selection(1)
if not selection:
hou.ui.displayMessage("Please select nodes to send.")
return
obj_context = hou.node("/obj")
selection_type = selection[0].type().category().name()
snippet_name_prompt = hou.ui.readInput("Enter snippet name:",
("OK", "Cancel"))
input_name = snippet_name_prompt[1]
input_name = input_name.replace(" ", "_")
snippet_name = "snp_" + input_name
if not snippet_name:
hou.ui.displayMessage("Please enter a snippet name")
return
snippet_subnet = obj_context.createNode("subnet",
node_name=snippet_name)
snippet_subnet.setColor(hou.Color(0.97, 0.78, 0.26))
snippet_subnet.setDisplayFlag(False)
if utils_hou.HOU_VER >= 16:
snippet_subnet.setUserData("nodeshape", "circle")
destination_node = snippet_subnet
if selection_type == "Sop":
destination_node = snippet_subnet.createNode("geo")
destination_node.setName("container_" + input_name)
if selection_type == "Vop":
destination_node = snippet_subnet.createNode("matnet")
destination_node.setName("container_" + input_name)
if selection_type == "Driver":
destination_node = snippet_subnet.createNode("ropnet")
destination_node.setName("container_" + input_name)
snippet_verif = snippet_subnet.createNode("subnet")
snippet_verif.setName("snippet_verification")
snippet_verif.setDisplayFlag(False)
snippet_verif.hide(True)
destination_node.setColor(hou.Color(0, 0, 0))
hou.copyNodesTo(selection, destination_node)
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 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 create_out_nodes():
#get nodes
nodes = hou.selectedNodes()
prefix = "OUT_"
for node in nodes:
#query each selected node and ask for it's out null name
null_name = hou.ui.readInput("Name for OUT-Null after:" + " " +
str(node),
buttons=("Create", "Cancel"))
#if "create" was clicked
if null_name[0] == 0:
#create null node, add underscores and capitalize the name, add black color to out null
out_null = node.createOutputNode(
"null", prefix + null_name[1].replace(" ", "_").upper())
out_null.setColor(hou.Color((0, 0, 0)))
#if "cancel" was clicked
else:
exit()
def normalizeGeoMaxSize():
"""
normalize by max size and centroid
"""
help(normalizeGeoMaxSize)
import hou
nodeSelect = hou.selectedNodes()
pink = hou.Color((0.98, 0.275, 0.275))
for node in nodeSelect:
wrangleSnippet = node.createOutputNode("attribwrangle",
"normalizeGeoVexByHeight")
wrangleSnippet.setColor(pink)
wrangleSnippet.setParms({
"snippet":
"""
//center geo
vector min, max;
getbbox(0, min, max);
vector centroid = (min+max)/2;;
@P+= centroid*-1;
@P*= 1/(max(max.x-min.x,max.y-min.y,max.z-min.z)); //normalize by max size
@P*=2;"""
})
def rotTool():
"""
help rotate scatter with orient attribute
"""
help(rotTool)
import hou
nodeSelect = hou.selectedNodes()
pink = hou.Color((0.98, 0.275, 0.275))
for node in nodeSelect:
wrangleSnippet = node.createOutputNode("attribwrangle", "rotTool")
wrangleSnippet.setColor(pink)
wrangleSnippet.setParms({
"snippet":
"""float x = rand(@ptnum);
float y = rand(@ptnum+311);
float z = rand(@ptnum-801);
@orient = sample_orientation_uniform(set(x,y,z));
"""
})
print(
"--- Don't forget create channels parameter in the wrangle node ---"
)
def normalizeGeoYVex():
"""
normalize the size of the geo and move it to zero
"""
help(normalizeGeoYVex)
import hou
nodeSelect = hou.selectedNodes()
pink = hou.Color((0.98, 0.275, 0.275))
for node in nodeSelect:
wrangleSnippet = node.createOutputNode("attribwrangle",
"normalizeGeoVexByHeight")
wrangleSnippet.setColor(pink)
wrangleSnippet.setParms({
"snippet":
"""
//center geo
vector min, max;
getbbox(0, min, max);
vector centroid = (min+max)/2;;
@P+= centroid*-1;
@P*= 1/(max.y-min.y); //normalize by max height
@P.y+=0.5; //normalize by max height
@P*=ch('realScale'); //real scale"""
})
print(
"--- Don't forget to just clic for create channels param in the wrangle node ---"
)
def create_alembic_single(paths):
node = hou.node("/obj")
hou.cd("/obj")
pos_y = 0
for key, value in paths.items():
# Create Geo node
pwd = hou.pwd().createNode("geo", node_name=key)
pos_y += 1
pwd.setPosition([2, pos_y])
hou.cd("/obj/" + str(pwd))
pwd.setColor(hou.Color(0, 0, 0))
# Create alembic node
alembic = hou.pwd().createNode("alembic")
alembic.setName(key)
# Set parameters
alembic.setParms({"fileName": value, "curveFilter": 0, "NURBSFilter": 0})
# Create Out node
transform = alembic.createOutputNode("xform", node_name="ScaleSmaller")
transform.parm("scale").set(0.01)
out = transform.createOutputNode("null", node_name="OUT")
out.setDisplayFlag(True)
out.setRenderFlag(True)
hou.cd("/obj")
hou.ui.displayMessage("Creating a successful", ["Ok"])
def __init__(self, node, rig_subnet):
print "character placer"
self.node = node
self.rig_subnet = rig_subnet
self.limb_subnet = self.create_rig_node(self.rig_subnet)
self.node_rename(self.node, self.limb_subnet)
self.position_node(self.node, self.limb_subnet)
null_ch = self.limb_subnet.createNode("null", "character_placer")
null_ch.parm("controltype").set(1)
null_ch.parm("geoscale").set(2)
null_ch.parm("orientation").set(2)
hook = hou_rig.my_null.my_null(self.limb_subnet, "hook_chain_0")
#hook = hou_rig.my_null.my_null(self.subnet, "character_placer_hook")
hook.setInput(0, null_ch)
hook.setColor(hou.Color((0.15, 0.15, 0.15)))
hook.parm("geoscale").set(1)
hook.parm("controltype").set(3)
hook.parm("orientation").set(2)
self.parameters_ui()
self.connect_parms()
self.limb_subnet.layoutChildren()
def create_object_merge():
offsetx = 3
offsety = 0
color = hou.Color(0.0, 0.0, 0.0)
for node_src in hou.selectedNodes():
name_src = node_src.name()
posx = node_src.position()[0] + offsetx
posy = node_src.position()[1] + offsety
#create, name, pos
container = node_src.parent().path()
name_mrg = "IN_" + name_src
node_mrg = hou.node(container).createNode('object_merge', name_mrg)
node_mrg.setPosition([posx, posy])
#parm
path_src = node_src.path()
parm = node_mrg.parm("objpath1")
parm.set(path_src)
#setcol
node_src.setColor(color)
node_mrg.setColor(color)
def render_palette():
"""
This func is return Preset Empty Rendergeometry
Samples***
render_palette()
"""
import hou
root = hou.node("/obj")
Pl_Node = root.createNode("geo", "Render_Palette", 1)
NodeColor = hou.Color((0.2, 0.5, 0.5))
Pl_Node.setColor(NodeColor)
Pl_Node.moveToGoodPosition()
Soppath = Pl_Node.path()
Innet = hou.node(Soppath)
importNode = Innet.createNode("object_merge", "IMPORT")
null = importNode.createOutputNode("null", "RenderOut")
null.setDisplayFlag(1)
del hou
def manuallyCreateGhost(self):
"""Create a ghost at the current frame for a selected objects. If it already exists, delete it and create a new one."""
ghosts = hou.selectedNodes()
if ghosts != ():
if hou.node("/obj/InBetween_ghost_folder"):
for node in hou.node("/obj").allItems():
if node.name() == "InBetween_ghost_folder":
ghost_geo_folder = node
ghost_mat_folder = hou.node(
"/obj/InBetween_ghost_folder/ghost_shaders/")
self.deleteExistingGhostAtFrame(
ghost_geo_folder, ghost_mat_folder, ghosts)
self.createGhost(ghost_mat_folder, ghost_geo_folder,
ghosts)
else:
with hou.undos.group("Create Ghost"):
ghost_geo_folder = hou.node('/obj').createNode(
'geo', node_name='InBetween_ghost_folder')
ghost_mat_folder = ghost_geo_folder.createNode(
'shopnet', 'ghost_shaders')
ghost_mat_folder.moveToGoodPosition()
ghost_geo_folder.setColor(hou.Color((0.3, 0.3, 0.3)))
ghost_geo_folder.setSelectableInViewport(0)
ghost_geo_folder.hide(1)
self.createGhost(ghost_mat_folder, ghost_geo_folder,
ghosts)
def update(self):
gobj = self.gameObject()
bbx = gobj.getComponent("BaseColliderComponent")
objs = [
x for x in gobj.findObjects(self.__collisionmask) if x is not gobj
]
node = gobj.getComponent("ShapeComponent").getHouNode()
clr = hou.Color(1, 1, 1)
for obj in objs:
if bbx.collidesWith(obj):
gobj.sendMessage("onCollide", obj)
obj.sendMessage("onCollide", gobj)
clr = hou.Color(1, 0, 0)
#break #DA F**K IS THIS BREAK HERE???
if (self.__dodebug):
node.setColor(clr)
def run(kwargs):
# Get Selected Node
selNodes = hou.selectedNodes()
# Create NULL
kwargs['bbox'] = hou.BoundingBox(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5)
mrg = objecttoolutils.genericTool(kwargs, 'null')
curNode = kwargs["pane"].currentNode()
# Make InputField
name = hou.ui.readInput("Call me Names", title="Name")[1]
# Remove Special Chars and replace them with "_"
for k in name.split("\n"):
name = re.sub(r"[^a-zA-Z0-9]+", ' ', k)
name = name.upper()
name = name.replace(" ", "_")
# Connect Node to Predecessor
if not kwargs['shiftclick']:
for x, node in enumerate(selNodes):
mrg.setNextInput(node)
# SetInterface
curNode.setName(name, True)
curNode.setColor(hou.Color((0, 1, 0)))
curNode.setDisplayFlag(True)
curNode.setRenderFlag(True)
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 sexGroupXformKey(self, set, node):
for key in set:
self.setKLoop(node, key, "rotatePivot", "x", "px")
self.setKLoop(node, key, "rotatePivot", "y", "py")
self.setKLoop(node, key, "rotatePivot", "z", "pz")
self.setKLoop(node, key, "translate", "x", "tx")
self.setKLoop(node, key, "translate", "y", "ty")
self.setKLoop(node, key, "translate", "z", "tz")
self.setKLoop(node, key, "rotate", "x", "rx")
self.setKLoop(node, key, "rotate", "y", "ry")
self.setKLoop(node, key, "rotate", "z", "rz")
self.setKLoop(node, key, "scale", "x", "sx")
self.setKLoop(node, key, "scale", "y", "sy")
self.setKLoop(node, key, "scale", "z", "sz")
for key in set.findall("anim"):
self.setKLoopAnim(node, key, "translateX", "tx")
self.setKLoopAnim(node, key, "translateY", "ty")
self.setKLoopAnim(node, key, "translateZ", "tz")
self.setKLoopAnim(node, key, "scaleX", "sx")
self.setKLoopAnim(node, key, "scaleX", "sy")
self.setKLoopAnim(node, key, "scaleX", "sz")
self.setKLoopAnimRot(node, key, "rotateX", "rx")
self.setKLoopAnimRot(node, key, "rotateY", "ry")
self.setKLoopAnimRot(node, key, "rotateZ", "rz")
c = hou.Color(1.0, 0, 0)
node.setColor(c)
def pointDeleteByProximity():
'''
if a point is to far from is neighbour then delete it
'''
help(pointDeleteByProximity)
import hou
nodeSelect = hou.selectedNodes()
pink = hou.Color((0.98, 0.275, 0.275))
for node in nodeSelect:
wrangleSnippet = node.createOutputNode("attribwrangle",
"pointDeleteByProximity")
wrangleSnippet.setColor(pink)
wrangleSnippet.setParms({
"snippet":
"""
int numPoint = chi("numPoint");
int mypc = pcopen(0,"P",@P,chf("radius"),numPoint);
@Cd= chramp("ramp",fit(pcnumfound(mypc),0,numPoint,0,1));
if (@Cd.x<chf("seuilColor"))removepoint(0,@ptnum);
"""
})
print("--- Don't forget to create the channel ---")
def onNodeCreated(self, kwargs):
self.plugin.onNodeCreated(kwargs)
state = self.getStateFromNode(kwargs)
task = state.ui.getTaskname()
kwargs["node"].parm("task").set(task)
state.ui.setOutputType(kwargs["node"].parm("format").evalAsString())
kwargs["node"].setColor(hou.Color(0.95, 0.5, 0.05))
def mat_check(node):
path = os.path.abspath(node.evalParm('path_mat'))
if not os.path.isfile(path):
print("material doesn't exist")
engine = node.evalParm('engine')
method = node.evalParm('method')
if method == 0:
smethod = 'soft'
elif method == 1:
smethod = 'rigid'
elif method == 2:
smethod = 'fluid'
elif method == 3:
smethod = 'sprite'
parm = smethod + "_mat_" + str(engine)
node.parm(parm).revertToDefaults()
mat = node.evalParm(parm)
directory = os.path.dirname(path)
if not os.path.exists(directory):
os.makedirs(directory)
with open(path, 'w+') as f:
f.write(mat)
component = str(node.evalParm('_component')) + '_mat'
componentPath = '/mat/' + component
matNode = hou.node(componentPath)
if not matNode:
matNode = hou.node('/mat').createNode('materialbuilder', component)
matNode.moveToGoodPosition()
matNode.setColor(hou.Color((0.0, 0.6, 1.0)))
def sopRopAndRead_MantraToAfanasy():
sel = hou.selectedNodes()
for n in range(0, len(sel)):
current = sel[n]
# if Mantra node selected
if str(current.type().name()) == "ifd":
af = current.createOutputNode("afanasy", "af_" + current.name())
af.setParmExpressions(
{"trange": "ch(\"../" + current.name() + "/trange\")"})
af.setParmExpressions({
"f1": "ch(\"../" + current.name() + "/f1\")",
"f2": "ch(\"../" + current.name() + "/f2\")",
"f3": "ch(\"../" + current.name() + "/f3\")"
})
#af.setParmExpressions({"take": "`chs(\"../"+current.name()+"/take\")`"})
af.parm("take").set("`chs(\"../" + current.name() + "/take\")`")
af.parm("platform").set("Linux")
af.parm("enable_extended_parameters").set(1)
af.parm("hosts_mask").set("tcp.*")
af.setColor(hou.Color((0, 0, 0)))
#if Geometry node selected
else:
file_read = current.createOutputNode("file", "file_read")
rop_output = current.createOutputNode("rop_geometry", "rop_geo")
rop_output.setParmExpressions({"f1": "$RFSTART", "f2": "$RFEND"})
rop_output.parm("alfprogress").set(1)
#file_read.setParmExpressions({"file": "`chs(\"../"+rop_output.name()+"sopoutput\")`"})
file_read.parm("file").set("`chs(\"../" + rop_output.name() +
"/sopoutput\")`")
rop_output.parm("sopoutput").set(
"$DATA/cache/$SCENENAME/`opname(\"..\")`/0000/`opname(\"..\")`.$F4.bgeo"
)
