Scripts

Houdini Scripts

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%")