Scripts

    •  

      Houdini Scripts

      Centre Pivots

      Sets pivot transforms to $CEX, $CEY, $CEZ on selected nodes

      # Centre pivots
      import hou
      
      sel = hou.selectedNodes()
      for nodes in sel:
          nodes.parm('px').setExpression('$CEX')
          nodes.parm('py').setExpression('$CEY')
          nodes.parm('pz').setExpression('$CEZ')
      

      Find/Replace Parameter Expression

      Will find/replace strings within selected nodes’ parameters’ expressions

      import hou
      
      sel = hou.selectedNodes()
              
      dialog = hou.ui.readMultiInput('Find/Replace In Expression', input_labels=['Find: ', 'Replace: ',], buttons=("Find/Replace", "Cancel"),
           severity=hou.severityType.ImportantMessage, title='Find/Replace', close_choice=1)
      
      find = dialog[1][0]
      replace = dialog[1][1]
      
      
      if dialog[0] == 0:
          for n in sel:
              for parms in n.parms():
                  try:
                      newString = str(parms.eval()).replace(find, replace)
                      parms.set(newString)
                  except:
                      print ''
                  try:
                      newExpression = str(parms.expression()).replace(find, replace)
                      parms.setExpression(newExpression)
                  except:
                      print ''
              

      Match Parameters

      Select two nodes and this script will copy all parameters from the first selected node to the second selected

      # --- This tool will match all parameters from the first selected node to the second.
      # --- good for copying ramps as well as the regular stuff.
      
      def matchParams():
          import hou
      
          value = 0
          sel = hou.selectedNodes()
      
          if len(sel) == 2:
              source = sel[0]
              dest = sel[1]
              for param in source.parms():
                  sourceParm = param.name()  # source parameter
                  destParm = dest.parm(sourceParm)  # Destination parameter
                  try:
                      destParm.deleteAllKeyframes()
                  except:
                      value += 1
                  try:
                      sourceLanguage = param.expressionLanguage()
                      destParm.setExpression(param.expression(), language=sourceLanguage)
      
                  except:
                      value += 1
                  try:
                      destParm.set(param.eval())
                  except:
                      value += 1
                  try:
                      destParm.set(param.unexpandedString())
                  except:
                      value += 1
      
                  if param.isLocked() == 'True':
                      destParm.lock(on)
          else:
              print 'Select two nodes to match parameters'
      
      matchParams()

      Toggle Update Mode

      This script will toggle between Manual and Auto Update modes

      if hou.ui.updateMode() == hou.updateMode.AutoUpdate:
          hou.ui.setUpdateMode(hou.updateMode.Manual)
      else:
          hou.ui.setUpdateMode(hou.updateMode.AutoUpdate)

      Set Camera Parameters

      A short example to set all camera parameters – specifically resolution and icon scale

      import hou
      ''' This script will set all cameras res to those determined below
          and icon scale'''
      
      resx = "1920"
      resy = "1080"
      iconsize = "100"
      
      cameras = hou.nodeType(hou.objNodeTypeCategory(), "cam")
      cameras.instances()
      
      for cams in cameras.instances():
          cams.parm("resx").set(resx)
          cams.parm("resy").set(resy)
          cams.parm("iconscale").set(iconsize)

      Softimage Scripts

      Move Selected Items to Background Partitions

      This script will move selected items into background partitions of either the current pass or multiple selected passes

      # Move selected objects to background partitions
       
      # created by Gareth Bell
       
      # original created in VBScript 28-11-11
      # converted to Python 26-07-2012
       
       
      # Description:
      # This script will put the selected objects into either the current passes bg partitions or, if selected, multiple passes bg partitions
       
      ##################################
       
      # To use:  select objects and passes. Run.
       
      ##################################
       
      import win32com
      xsi = Application
       
      #create collections to store objects
      geoColl = win32com.client.Dispatch( "XSI.Collection" )
      passesColl = win32com.client.Dispatch( "XSI.Collection" )
      lightsColl = win32com.client.Dispatch( "XSI.Collection" )
       
      selection = win32com.client.Dispatch( "XSI.Collection" )
      selection.AddItems (xsi.Selection)
       
      #sort selection into collections (objects, lights and passes)
      for obj in selection:
                if obj.type == "light":
                         lightsColl.AddItems (obj)
                elif obj.type == "Pass":
                         passesColl.AddItems (obj)
                else:
                         geoColl.AddItems (obj)
                        
      passCount = passesColl.Count
       
      #decide if sorting is in only the current pass or multiple passes
      if passCount > 0:
                for eachPass in passesColl:     
      			print str(geoColl) + " has/have been put into the background partition in " + str(eachPass.name)
      			xsi.MoveToPartition(str(eachPass) + ".background_objects_partition", geoColl, eachPass)
      			print str(lightsColl) + " has/have been put into the background partition in " + str(eachPass.name)
      			xsi.MoveToPartition(str(eachPass) + ".background_lights_partition", lightsColl, eachPass)
      else:
      	currentPass = xsi.ActiveProject.ActiveScene.ActivePass
      	print str(geoColl) + " has/have been put into the background partition in the current pass"
      	xsi.MoveToPartition(str(currentPass) + ".background_objects_partition", geoColl, currentPass)               
      	print str(lightsColl) + " has/have been put into the background partition in the current pass"
      	xsi.MoveToPartition(str(currentPass) + ".background_lights_partition", lightsColl, currentPass)    
      				   
      				   

      Convert Models to Nulls

      This small script will convert selected models into nulls.

      import win32com
      xsi = Application
       
      objs = win32com.client.Dispatch( "XSI.Collection" )
      objs.AddItems (xsi.Selection)
       
       
      for i in objs:
                if i.Type == "#model":
                         newNull = xsi.GetPrim("null", str(i) + "_null", "", "")   #create null
                         xsi.MatchTransform(newNull, i, "siSRT")   #match it's transforms to the model
                        
                         for eachChild in i.Children:  #parent model's children to null
                                   xsi.ParentObj(newNull, eachChild)
                                  
                         try:
                                   for eachGroup in i.Groups:   #move groups to nulls parent
                                            xsi.CopyPaste (eachGroup,"", newNull.Parent, 1)
                         except:
                                   print ""
       
                         try:
                                   xsi.ParentObj (i.Parent, newNull)    #parent new null to original models parent
                         except:
                                   print ""
       
       
                         xsi.DeleteObj (i)    #Delete original model
               
                else:
                         print "Select models only"

      mia2vray Material Conversion

      This small script will swap selected materials mia shaders into vraymtrl shaders. This script was inspired by Paul Driesen’s script for Maya 

      #mia2vray converter
      #author: gareth bell
      #date: 15-10-2012
      
      #This script will break the back of converting mia shaders in selected materials into vrayMtls
      
      #Use: Select materials. Run
      
      import win32com.client
      import siutils
      
      from siutils import si
      from siutils import C
      
      xsi = Application
      coll = win32com.client.Dispatch( "XSI.Collection" )
      vrayMaterials = win32com.client.Dispatch( "XSI.Collection" )
      
      
      #############################################
      def traverse( s, coll ):
          for p in s.Parameters:
              if p.Source and p.Source.IsClassOf( C.siShaderParameterID ):
                  coll.Add( p.Source.Parent )
                  traverse( p.Source.Parent, coll )
      
          for l in s.TextureLayers:
              for y in l.Parameters:
                  if y.Source and y.Source.IsClassOf( C.siShaderParameterID ):
                      coll.Add( y.Source.Parent ) 
                      traverse( y.Source.Parent, coll )
      		  
      ############################################
      
      def createVrayShader (eachShader):
      			vrayMaterial = xsi.CreateShaderFromProgID("Softimage.VRayMtl.1.0", mat, "VRayMtl")
      			vrayMaterials.AddItems (vrayMaterial) 
      			miaName = eachShader.name
      			vrayName = vrayMaterial.FullName
      			
      			#match diffuse colour
      			xsi.SetValue( (str(vrayName) + ".diffuse_color.red"), eachShader.diffuse.red.value, "")
      			xsi.SetValue( (str(vrayName) + ".diffuse_color.green"), eachShader.diffuse.green.value, "")
      			xsi.SetValue( (str(vrayName) + ".diffuse_color.blue"), eachShader.diffuse.blue.value, "")
      			
      			#match reflection colour
      			xsi.SetValue( (str(vrayName) + ".reflection_color.red"), eachShader.refl_color.red.value, "")
      			xsi.SetValue( (str(vrayName) + ".reflection_color.green"), eachShader.refl_color.green.value, "")
      			xsi.SetValue( (str(vrayName) + ".reflection_color.blue"), eachShader.refl_color.blue.value, "")
      			
      			#match refraction colour
      			xsi.SetValue( (str(vrayName) + ".refr_color.red"), eachShader.refr_color.red.value, "")
      			xsi.SetValue( (str(vrayName) + ".refr_color.green"), eachShader.refr_color.green.value, "")
      			xsi.SetValue( (str(vrayName) + ".refr_color.blue"), eachShader.refr_color.blue.value, "")
      			
      			#match roughness
      			xsi.SetValue( (str(vrayName) + ".roughness"), eachShader.diffuse_roughness.value, "")
      			
      			#match gloss
      			xsi.SetValue( (str(vrayName) + ".refr_glossiness"), eachShader.refr_gloss.value, "")
      			
      			#match IOR
      			xsi.SetValue( (str(vrayName) + ".refr_ior"), eachShader.refr_ior.value, "")
      			
      			#match anisotropy
      			a = eachShader.anisotropy.value
      			#equation for getting anisotropy values in range 0 to 10 (mia_shader) converted to -1 to 1 (vray_shader) is (a/5.0)-1)
      			xsi.SetValue( (str(vrayName) + ".brdf_anisotropy"), (a/5.0)-1.0)
      			
      			#match rotation
      			xsi.SetValue( (str(vrayName) + ".brdf_rotation"), eachShader.anisotropy_rotation.value, "")
      			
      			#match fresnel
      			fres = eachShader.brdf_fresnel.value
      			if fres == True:
      				xsi.SetValue( (str(vrayName) + ".reflection_enable_fresnel"), False, "")
      			else:
      				xsi.SetValue( (str(vrayName) + ".reflection_enable_fresnel"), True, "")
      			
      			inputCnx = win32com.client.Dispatch( "XSI.Collection" )
      			cnxPoint = win32com.client.Dispatch( "XSI.Collection" )
      			
      			for p in eachShader.Parameters:
      				if p.Source and p.Source.IsClassOf( C.siShaderParameterID ):
      					inputCnx.Add (p.Source.Parent)
      					cnxPoint.Add (p)
      
      			for i in range (0, inputCnx.Count):
      				#print inputCnx(i)
      				#print cnxPoint(i).Name
      				
      				if cnxPoint(i).Name == "diffuse":
      					vrayCnxPoint = "diffuse_color"
      				elif cnxPoint(i).Name == "refl_color":
      					vrayCnxPoint = "reflection_color"
      				elif cnxPoint(i).Name == "refr_color":
      					vrayCnxPoint == "refr_color"
      				elif cnxPoint(i).Name == "roughness":
      					vrayCnxPoint == "diffuse_roughness"
      				elif cnxPoint(i).Name == "refr_glossiness":
      					vrayCnxPoint == "refr_gloss"
      				elif cnxPoint(i).Name == "refr_ior":
      					vrayCnxPoint == "refr_ior"
      				elif cnxPoint(i).Name == "anisotropy":
      					vrayCnxPoint == "brdf_anisotropy"
      				elif cnxPoint(i).Name == "brdf_rotation":
      					vrayCnxPoint == "anisotropy_rotation"
      				
      				xsi.SIConnectShaderToCnxPoint( (inputCnx(i).out) , str(vrayName) + "." + str(vrayCnxPoint))
      				
      			#match name to mia_name
      			xsi.SetValue((str(vrayName) + ".Name"), "VRay" + str(eachShader.name)[3:])
      
      
      #############################################################
      #############################################################
      
      
      prefs = xsi.Preferences
      #get commandlog prefs
      origPrefs = prefs.GetPreferenceValue ("scripting.cmdlog")
      #turn log off
      prefs.SetPreferenceValue ("scripting.cmdlog", False)
      
      # get material
      for mat in xsi.Selection:
      	traverse( mat, coll )
      	coll.Unique = True
      	
      	for eachShader in coll:
      		if "Softimage.mia_material_phen.1.0" in eachShader.ProgID:
      			print ""          
      		elif "mentalray.mia_material_x.1.0" in eachShader.ProgID:
      			print ""
      		else:
      			coll.Remove( eachShader )
      
      	for eachShader in coll:
      		createVrayShader (eachShader)
      	#get mia shaders output connections and plug them into the newly created vRay shader
      	for s in range (0, coll.count):
      		targets = coll(s).GetShaderParameterTargets("")	
      		for eachTarget in targets:
      			xsi.SIConnectShaderToCnxPoint(str(vrayMaterials(s)) + ".out" , eachTarget, False)
      			
      		#delete mia shader
      		xsi.DeleteObj (coll(s))
      		
      	#empty collections
      	vrayMaterials.RemoveAll()
      	coll.RemoveAll()
      		
      #restore original log prefs	
      prefs.SetPreferenceValue ("scripting.cmdlog", origPrefs)
      

      Extrude Along Multiple Curves

      It came to my attention from a colleague today that there isn’t an easy way to extrude along multiple curves in Softimage. So I knocked up this little script for her.

      #extrudeMultiCurves_001
      
      #To Use: 
      # 1) Select the curves you want to extrude along.
      # 2) Run script
      # 3) Pick the profile curve
      
      
      import win32com
      xsi = Application
      
      #collect all curves
      extCurves = win32com.client.Dispatch( "XSI.Collection" )
      extCurves.AddItems (xsi.Selection)
      
      #pick profile curve
      profileCurve = xsi.PickElement ("", "Pick Profile Curve")
      
      #loop through all extCurves and extrude along profileCurve
      for i in range (0, extCurves.count):
      	xsi.ApplyGenOp("Extrusion", "MeshSurface", str(profileCurve(2)) + ";" + str(extCurves(i)), 3, "siPersistentOperation", "siKeepGenOpInputs", "")

      Delete Empty Partitions

      I like to keep my passes tidy so this little script just strips out any empty partitions on selected passes.

      #  USE: Select passes and run the script
      
      import win32com
      
      xsi = Application
      
      selectedPasses = win32com.client.Dispatch( "XSI.Collection" )
      selectedPasses.AddItems (xsi.Selection)
      
      #--------------------------------------------------------------
      #--------------------------------------------------------------
      #--------------------------------------------------------------
      
      def stripPass(eachPass):
      	partitionsColl = win32com.client.Dispatch( "XSI.Collection" )
      	for eachPartition in eachPass.Partitions:
      		partitionsColl.AddItems (eachPartition)
      	
             #-- Remove background partitions from the collection ---------------------
      	partitionsColl.RemoveItems (partitionsColl[0])
      	partitionsColl.RemoveItems (partitionsColl[0])
      	
      	for eachPartition in partitionsColl:
      		if eachPartition.Members.Count == 0:
      			print str(eachPartition) + " is empty :: Deleted ::"
      			xsi.DeleteObj (eachPartition)
      
      #--------------------------------------------------------------
      #--------------------------------------------------------------
      
      
      for eachPass in selectedPasses:
      	stripPass(eachPass)
      	

       

      Nuke Scripts

      Multi Paster

      A simple snippet to paste multiples of the copied node underneath the selected nodes.
      To use just copy the node you want (ctrl-c). Select the nodes on which you want to paste the copies and run the script. Simples!

      #paste to multiple selection
      selected = nuke.selectedNodes()
      
      for eachNode in selected:
          n = nuke.toNode(str(eachNode.name()))
          n.knob("selected").setValue(True)
          nuke.nodePaste("%clipboard%")