def setProj(base):
invalid = True
while invalid:
userdir = hou.ui.selectFile(title="Please choose a Project Directory",
collapse_sequences=True,
file_type=hou.fileType.Directory)
#Search for ENVVARS
reg = re.compile('(\${1})([A-Z]+)')
match = reg.search(userdir)
if match:
first, second = match.groups()
myPath = hou.getenv(second)
length = len(second) + 1
#Replace Them
userdir = myPath + userdir[length:]
if os.path.isdir(userdir):
invalid = False
#Create Direcotries
ud = userdir
makeDirs(userdir)
userdir = userdir + base
else:
hou.ui.displayMessage("Please select a directory")
hou.putenv("JOB", userdir)
return ud
def toggle_dependencies():
parm_pane = wf_selection.pane_linkGroup(hou.paneTabType.NetworkEditor)
view_dependencies = hou.getenv("view_dependencies", "0")
if view_dependencies == "0": view_dependencies = "1"
else: view_dependencies = "0"
hou.putenv("view_dependencies", view_dependencies)
parm_pane.setPref('showdep', str(view_dependencies))
def _setenv(self, parent_tokens):
"""Env tokens common for all Job types.
First we collect up token values for the job and set the env to
those values. Then we merge with tokens from the parent so that
in the preview display the user can see all tokens available at
the Job level, including those that were set at the submitter
level.
"""
tokens = {}
seq = self._sequence["main"]
tokens["CT_SEQLENGTH"] = str(len(seq))
tokens["CT_SEQUENCE"] = str(seq)
tokens["CT_SEQUENCEMIN"] = str(seq.start)
tokens["CT_SEQUENCEMAX"] = str(seq.end)
tokens["CT_CORES"] = str(self._instance["cores"])
tokens["CT_FLAVOR"] = self._instance["flavor"]
tokens["CT_INSTANCE"] = self._instance["description"]
tokens["CT_PREEMPTIBLE"] = (
"preemptible" if self._instance["preemptible"] else "non-preemptible")
tokens["CT_RETRIES"] = str(self._instance["retries"])
tokens["CT_JOB"] = self.node_name
tokens["CT_SOURCE"] = self.source_path
tokens["CT_TYPE"] = self.source_type
for token in tokens:
hou.putenv(token, tokens[token])
tokens.update(parent_tokens)
return tokens
def _setenv(self, parent_tokens):
"""Env tokens at the task level.
Task level tokens are joined with Job and submission
level tokens so that all tokens are available when
constructing the task command.
Example:
python myCmd.py -s $CT_CHUNKSTART -e $CT_CHUNKEND -n $CT_SOURCE -f $CT_SCENE
"""
tokens = {}
chunk_type = "regular" if self._chunk.is_progression() else "irregular"
tokens["CT_CHUNKTYPE"] = chunk_type
tokens["CT_CHUNK"] = str(self._chunk)
tokens["CT_CHUNKLENGTH"] = str(len(self._chunk))
tokens["CT_CHUNKSTART"] = str(self._chunk.start)
tokens["CT_CHUNKEND"] = str(self._chunk.end)
tokens["CT_CHUNKSTEP"] = str(
self._chunk.step) if chunk_type == "regular" else "~"
for token in tokens:
hou.putenv(token, tokens[token])
tokens.update(parent_tokens)
return tokens
def play_scrub(multiplier):
import time
from PySide2.QtGui import QCursor
mouse_last = hou.getenv("mouse", "0")
mouse_last = float(mouse_last)
mouse_now = QCursor().pos()
time_now = time.time()
time_last = hou.getenv("time", "0")
time_last = float(time_last)
time_diff = time_now - time_last
mouse_now = round(mouse_now.x() / 10)
if time_diff > 0.1:
mouse_last = mouse_now
skip = mouse_last - mouse_now
skip = skip * multiplier
if abs(skip) > 20:
skip = skip * 2
frame_now = hou.frame()
frame_now = hou.frame() - skip
hou.setFrame(frame_now)
hou.putenv("mouse", str(mouse_now))
hou.putenv("time", str(time_now))
def toggle_ghostother():
view_ghost = hou.getenv("view_ghost", "2")
if view_ghost == "0": view_ghost = "2"
else: view_ghost = "0"
hou.putenv("view_ghost", view_ghost)
script = "vieweroption -a " + view_ghost + " %s`run('viewls -n')`"
hou.hscript(script)
def set_job(self, kwargs):
path = hou.hipFile.path()
basename = len(hou.hipFile.basename())
path = path[:-basename]
hou.putenv('JOB', path)
kwargs['node'].parm('job').set(path)
def toggle_maskoverlay () :
view_maskoverlay = hou.getenv("view_maskoverlay", "1.0")
if view_maskoverlay == "1.0": view_maskoverlay = "0.4"
else: view_maskoverlay = "1.0"
hou.putenv("view_maskoverlay", view_maskoverlay)
script = "viewmaskoverlay -o " + view_maskoverlay + " *"
hou.hscript(script)
def set_project(kwargs):
node = kwargs['node']
project_name = node.evalParm('proj')
# project_name = kwargs['script_value']
node.parm('scene').set('')
unset_all_scene_vars()
data = read_json()
if project_name == '-':
hou.unsetenv('PROJECT')
hou.unsetenv('CODE')
hou.unsetenv('PROJ_FPS')
hou.setFps(24)
hou.unsetenv('PROJECT_PATH')
hou.unsetenv('SCENES_PATH')
hou.unsetenv('HDA_PATH')
hou.unsetenv('SCRIPTS_PATH')
node.cook(True)
return
try:
project_data = data[project_name]
except KeyError:
util.error('Project Data not found')
return
hou.putenv('PROJECT', project_name)
hou.putenv('CODE', project_data['CODE'])
fps = project_data['FPS']
hou.putenv('PROJ_FPS', str(fps))
hou.setFps(fps)
project_path = project_data['PATH']
hou.putenv('PROJECT_PATH', project_data['PATH'])
create_folder_and_var('SCENES_PATH', util.fix_path(os.path.join(project_path, 'scenes')))
hda_path = util.fix_path(os.path.join(project_path, 'hda'))
create_folder_and_var('HDA_PATH', hda_path)
scripts_path = util.fix_path(os.path.join(project_path, 'scripts'))
create_folder_and_var('SCRIPTS_PATH', scripts_path)
hda_paths = [hda_path, ]
scan_path = hou.getenv('HOUDINI_OTLSCAN_PATH')
if scan_path:
hda_paths += scan_path.split(';')
hda_paths = list(set(hda_paths))
hou.putenv('HOUDINI_OTLSCAN_PATH', ';'.join(hda_paths))
hou.hda.reloadAllFiles()
sys.path.append(scripts_path)
node.cook(True)
def action_set_project(self):
path = os.path.join(self.site_path, self.ui_proj_name.currentText())
if os.path.exists(path) is False:
raise Exception('Error while setting project to {}'.format(path))
self.proj_path = path
self.proj_name = os.path.basename(self.proj_path)
hou.putenv('job', path)
self.hou_env_in_ui()
self.get_project_files()
def create_folder_and_var(var, path):
path = util.fix_path(path)
hou.putenv(var, path)
if not os.access(path, os.F_OK):
os.makedirs(path)
print('Creating variable {0} and folder [{1}]'.format(var, path))
return
def updateEntry(self, kwargs):
val = kwargs['parm']
env_var = (kwargs['parm_name'].upper())
if kwargs['parm'].name() == 'c_version':
val = val.evalAsString().rjust(3, '0')
hou.putenv(env_var, val)
return
hou.putenv(env_var, val.evalAsString())
def __init__(self, node):
"""Collect member data from the Houdini UI.
If the submission has been instantiated from a
conductor::job node, then the submission data will
be pulled from the submission tab, and the same node
will be used as the only Job. Both self._node and
self._jobs will point to the same node. If instead
it is instantiated from a conductor::submitter
node, then it will provide top level submission data
and the Jobs (self._jobs) will built from the
conductor::submitter's input nodes.
* Generate a timestamp which will be common to all jobs.
* Get the basename of the file in case its needed as a token.
* Scene name - see notes on scene name in the Job.
* Get upload flags and notification data.
* Get the project.
After _setenv has been called, the Submission level token
variables are valid and calls to eval string attributes will
correctly resolve where those tokens have been used. This is
why we eval jobs after the call to _setenv()
"""
self._node = node
if types.is_job_node(self._node):
self._nodes = [node]
else:
self._nodes = node.inputs()
self._use_timestamped_scene = bool(
self._node.parm("use_timestamped_scene").eval())
self._timestamp = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M_%S')
hou.putenv("CT_TIMESTAMP", self._timestamp)
self._scene = self._node.parm("scene_file").eval()
self._upload = {
"local": bool(self._node.parm("local_upload").eval()),
"force": bool(self._node.parm("force_upload").eval()),
"only": bool(self._node.parm("upload_only").eval())
}
self._project = self._get_project()
self._tokens = self._setenv()
self._notifications = notifications_ui.get_notifications(self._node)
self._jobs = []
for node in self._nodes:
job = Job.create(node, self._tokens, self._scene)
self._jobs.append(job)
def toggle_objkinoverride () :
view_objkinoverride = hou.getenv("view_objkinoverride", "none")
if view_objkinoverride == "none": view_objkinoverride = "capture"
else: view_objkinoverride = "none"
hou.putenv("view_objkinoverride", view_objkinoverride)
script = "objkinoverride " + view_objkinoverride
hou.hscript(script)
paneTabs = hou.ui.currentPaneTabs()
for paneTab in paneTabs:
if paneTab.type().name() == 'SceneViewer':
paneTab.curViewport().draw()
def SetProjectPath():
'''
从 $HIPFILE 路径后面往前，搜到带 "houdini" 就设置此路径为 $JOB
'''
filePath = hou.hipFile.path()
filePath = filePath.split('/')
for i in range(len(filePath)):
if 'houdini' in filePath[-1].lower():
break
filePath.pop()
prjPath = '/'.join(filePath)
hou.putenv('JOB', prjPath)
print('$' + 'JOB = ' + hou.getenv('JOB', 'None'))
def launchProject(self, filePath):
tokenDict = self.get_token_dict()
self.houdini_tools.debug_msg("Setting environment variables: ")
for token in tokenDict:
os.environ[token] = tokenDict[token]
self.houdini_tools.debug_msg(token + " = " + tokenDict[token])
self.houdini_tools.debug_msg("Here we go!")
hou.allowEnvironmentToOverwriteVariable("JOB", True)
hou.putenv("JOB", "COOL DUDE")
forwardSlashPath = filePath.replace('\\', '/')
hou.hipFile.load(forwardSlashPath)
return True
def set_scene(kwargs):
node = kwargs['node']
scene_name = node.evalParm('scene')
# If null scene > unset all
if scene_name == '':
unset_all_scene_vars()
node.cook(True)
return
# If no PROJECT_PATH var
project_path = hou.getenv('PROJECT_PATH')
if not project_path or not os.access(project_path, os.F_OK):
util.error('Project path is invalid')
return
# If no SCENES_PATH var
scenes_path = hou.getenv('SCENES_PATH')
if not scenes_path or not os.access(scenes_path, os.F_OK):
util.error('Scenes path is invalid')
return
# If SCENES_PATH var but no folder
if not os.access(scenes_path, os.F_OK):
os.makedirs(scenes_path)
scene_path = util.fix_path(os.path.join(scenes_path, scene_name))
if not os.access(scene_path, os.F_OK):
message = 'Scene folder "{0}" does not exist\n'\
'Create this folder now?'.format(scene_name)
choice = hou.ui.displayMessage(message, severity=hou.severityType.ImportantMessage, buttons=('Yes', 'No'))
if choice == 0:
os.makedirs(scene_path)
else:
unset_all_scene_vars()
node.cook(True)
return
hou.putenv('SCENE', scene_name)
hou.putenv('SCENE_PATH', scene_path)
create_folder_and_var('SAVE_PATH', os.path.join(scene_path, 'working_files'))
output_path = os.path.join(scene_path, 'output')
create_folder_and_var('OUTPUT_PATH', output_path)
create_folder_and_var('CACHE_PATH', os.path.join(output_path, 'cache'))
create_folder_and_var('RENDER_PATH', os.path.join(output_path, 'render'))
node.cook(True)
def selection_switch():
nodes = hou.selectedNodes()
count = len(nodes)
if count > 1:
# if few nodes are selected, then initialize, save that selection
selection_stack = ','.join(node.path() for node in nodes)
hou.putenv('selection_stack', selection_stack)
hou.putenv('selection_current', '0')
hou.putenv('selection_count', str(count))
else:
# hou.ui.displayMessage("ikoon: select more than one node")
# return
pass
# even if one node is selected...
selection_stack = hou.getenv('selection_stack', 'none')
selection_current = hou.getenv('selection_current', 'none')
selection_count = hou.getenv('selection_count', 'none')
# go to next node...
stack = selection_stack.split(',')
current = int(selection_current) + 1
count = int(selection_count)
if current == count:
current = 0
# update the saved variable
hou.putenv('selection_current', str(current))
# select that node in current pane
target = hou.node(stack[current])
parm_pane = wf_selection.pane_linkGroup(hou.paneTabType.Parm)
parm_pane.setCurrentNode(target, True)
def toggle_wireover () :
set_scen, set_disp, set_ghos = view_sets()
view_wire = hou.getenv("view_wire", "0")
if view_wire == "0": view_wire = "1"
else: view_wire = "0"
hou.putenv("view_wire", view_wire)
if set_disp.shadedMode() == hou.glShadingType.SmoothWire and view_wire == "0":
set_disp.setShadedMode(hou.glShadingType.Smooth)
set_scen.setShadedMode(hou.glShadingType.Smooth)
set_ghos.setShadedMode(hou.glShadingType.Smooth)
if set_disp.shadedMode() == hou.glShadingType.Smooth and view_wire == "1":
set_disp.setShadedMode(hou.glShadingType.SmoothWire)
set_scen.setShadedMode(hou.glShadingType.SmoothWire)
set_ghos.setShadedMode(hou.glShadingType.SmoothWire)
def set_hip_and_job_vars(self, set_hip_explicit=None):
""" Set the $HIP and $JOB env vars to the correct location.
$HIP defaults to user scene dir unless set_hip_explicit is given.
"""
if set_hip_explicit is None:
hip_dir = os_wrapper.absolutePath(
'$IC_HOUDINI_SCENES_DIR/$IC_USERNAME')
else:
hip_dir = os_wrapper.absolutePath(set_hip_explicit)
job_dir = os_wrapper.absolutePath('$IC_HOUDINI_PROJECT_DIR')
# Create $HIP dir if it doesn't exist
if not os.path.isdir(hip_dir):
os_wrapper.createDir(hip_dir)
# Set vars
os.environ['HIP'] = hip_dir
hou.putenv('HIP', hip_dir)
os.environ['JOB'] = job_dir
hou.putenv('JOB', job_dir)
def _setenv(self, parent_tokens):
"""Extra env tokens available to the user for a ChunkedJob.
These tokens include information such as chunk_count and
chunk_size in case the user wants to use them to construct
strings.
"""
tokens = {}
tokens["CT_SCOUT"] = str(self._sequence["scout"])
tokens["CT_CHUNKSIZE"] = str(self._sequence["main"].chunk_size)
tokens["CT_CHUNKCOUNT"] = str(self._sequence["main"].chunk_count())
tokens["CT_SCOUTCOUNT"] = str(len(self._sequence["scout"] or []))
for token in tokens:
hou.putenv(token, tokens[token])
tokens.update(parent_tokens)
super_tokens = super(ChunkedJob, self)._setenv(parent_tokens)
tokens.update(super_tokens)
return tokens
def hou_env_check(self):
self.proj_path = hou.getenv('JOB')
self.site_path = hou.getenv('HSITE')
if os.path.exists(self.site_path) is False:
raise Exception("HSITE path doesn't exists : {}".format(
self.site_path))
if os.path.exists(self.proj_path) is False:
hou.putenv('job', self.site_path)
self.proj_path = self.site_path
if self.proj_path.startswith("C:"):
self.proj_name = None # TODO Overwrite $JOB ??
else:
self.proj_name = os.path.basename(self.proj_path)
proj_list = os.listdir(self.site_path)
filter = ['Substance Designer']
for i in proj_list:
if i in filter:
proj_list.remove(i)
self.proj_list = proj_list
def _setenv(self):
"""Env tokens are variables to help the user build strings.
The user interface has fields for strings such as
job title, task command, metadata. The user can use
these tokens, prefixed with a $ symbol, to build
those strings. Tokens at the Submission level are
also available in Job level fields, and likewise
tokens at the Job level are available in Task level
fields. However, it makes no sense the other way,
for example you can't use a chunk token (available
at Task level) in a Job title because a chunk
changes for every task.
We use hou.putenv() which basically sets these as
global env vars in the scene. Unfortunately thats the
only way because you can only attach variables local
to nodes through the Houdini devkit.
Once tokens are set, strings using them are expanded
correctly. In fact we don't need these tokens to be
stored on the Submission object (or Job or Task) for
the submission to succeed. The only reason we store
them is to display them in a dry-run scenario.
"""
tokens = {}
tokens["CT_TIMESTAMP"] = self._timestamp
tokens["CT_SUBMITTER"] = self._node.name()
# tokens["CT_HIPBASE"] = self._file["hipbase"]
tokens["CT_SCENE"] = self._scene
tokens["CT_PROJECT"] = self.project_name
for token in tokens:
hou.putenv(token, tokens[token])
return tokens
def setupQuick():
print "scene quick setup"
filepath = hou.hipFile.name()
path_list = splitall(filepath)
shot = path_list[-2]
show = path_list[-3]
hou.putenv("SHOT",shot)
hou.putenv("SHOW",show)
cache = "/studio/cache/job"
hou.putenv("CACHE",cache)
# hou.putenv("TEST","blabla")
print "setting SHOW to %s" % show
print "setting SHOT to %s" % shot
print "setting CACHE to %s" % cache
def readFromFile(self, kwargs):
path = hou.hipFile.path()
basename = len(hou.hipFile.basename())
path = path[:-basename]
# Set $NAME
basename = hou.hipFile.basename()
basename = basename[:basename.rfind(".")]
base_list = basename.split('_')
if len(base_list) == 4:
# Set DATE
kwargs['node'].parm('p_date').set(base_list[0])
# Set NAME
kwargs['node'].parm('p_name').set(base_list[1])
# Set USER
kwargs['node'].parm('p_user').set(base_list[2])
# SET VERSION
kwargs['node'].parm('p_version').set(base_list[3])
else:
# Check against Filename without Seperator
if len(basename.split('_')) > 1:
p_name = basename.split('_')[1]
else:
p_name = ""
kwargs['node'].parm('p_name').set(p_name)
kwargs['node'].parm('p_user').set(hou.getenv('USER'))
date = str(datetime.date.today()).replace('-', '')[2:]
kwargs['node'].parm('p_date').set(date)
kwargs['node'].parm('p_version').set('001')
# Update Env-Vars
hou.putenv('P_NAME', kwargs['node'].parm('p_name').evalAsString())
hou.putenv('P_USER', kwargs['node'].parm('p_user').evalAsString())
hou.putenv('P_DATE', kwargs['node'].parm('p_date').evalAsString())
hou.putenv('P_VERSION',
kwargs['node'].parm('p_version').evalAsString())
def _activateCurrentShot(self):
item = self.shotsList.selectedItems()[0]
shot_name = item.text()
shot_data = re_project.get_shot_data_from_name(shot_name)
shot_path = re_project.get_shot_path(shot_data[0], shot_data[1])
shot_path = shot_path / "houdini"
if hou.getenv("JOB") != shot_path.as_posix():
hou.putenv("JOB", shot_path.as_posix())
if hou.getenv("HIP") != shot_path.as_posix():
hou.putenv("HIP", shot_path.as_posix())
#hou.putenv("SHOTNAME", shot_name);
hou.hscript("set -g SHOTNAME={}".format(shot_name))
#hip_path = Path(hou.hipFile.path())
#hou.putenv("HIPFILE", hip_path.as_posix())
temp_path = shot_path / "tmp"
if hou.getenv("TEMP") != temp_path.as_posix():
hou.putenv("TEMP", temp_path.as_posix())
def _activateCurrentAsset(self):
item = self.assetList.selectedItems()[0]
asset_name = item.text()
asset_path = re_project.get_asset_path(asset_name)
asset_path = asset_path / "houdini"
if hou.getenv("JOB") != asset_path.as_posix():
hou.putenv("JOB", asset_path.as_posix())
if hou.getenv("HIP") != asset_path.as_posix():
hou.putenv("HIP", asset_path.as_posix())
#hou.putenv("ASSETNAME", asset_name)
hou.hscript("set -g ASSETNAME={}".format(asset_name))
#hip_path = Path(hou.hipFile.path())
#hou.putenv("HIPFILE", hip_path.as_posix())
#
temp_path = asset_path / "tmp"
if hou.getenv("TEMP") != temp_path.as_posix():
hou.putenv("TEMP", temp_path.as_posix())
def initVars():
hipname = hou.getenv('HIPNAME')
if hipname != 'untitled':
attribs = hipname.split("_")
if len(attribs) == 6:
hou.putenv('SHOT', attribs[0])
hou.putenv('SHOTNAME', attribs[1])
hou.putenv('TASK', attribs[2])
hou.putenv('TASKNAME', attribs[3])
hou.putenv('USER', attribs[4])
hou.putenv('VER', attribs[5])
elif len(attribs) == 4:
hou.putenv('TASK', attribs[0])
hou.putenv('ASSET', attribs[1])
hou.putenv('USER', attribs[2])
hou.putenv('VER', attribs[3])
elif len(attribs) > 0:
hou.putenv('VER', attribs[-1])
def set_envs(self, file_path):
# setup Shotgun base functions
eng = sgtk.platform.current_engine()
tk = sgtk.sgtk_from_path(file_path)
fields_template = tk.template_from_path(file_path)
entity_type = eng.context.entity.get('type')
root_template = None
# determine context and get templates
if entity_type:
if entity_type in ['shot', 'Shot', 'SHOT']:
root_template = tk.templates['houdini_shot_render_step_ver']
cache_root = tk.templates['houdini_shot_cache_root']
flip_root = tk.templates['houdini_shot_playblast_root']
alembic_root = tk.templates['houdini_shot_alembic_root']
elif entity_type in ['asset', 'Asset', 'ASSET']:
root_template = tk.templates['houdini_asset_render_step_ver']
cache_root = tk.templates['houdini_asset_cache_root']
flip_root = tk.templates['houdini_asset_playblast_root']
alembic_root = tk.templates['houdini_asset_alembic_root']
# generate output roots for renders/caches/flipbooks
curr_fields = fields_template.get_fields(file_path)
output_root = root_template.apply_fields(curr_fields)
cache_output = cache_root.apply_fields(curr_fields)
flip_output = flip_root.apply_fields(curr_fields)
alembic_output = alembic_root.apply_fields(curr_fields)
hou.putenv("RENDER_ROOT", output_root.replace(os.path.sep, '/'))
hou.putenv("CACHE_ROOT", cache_output.replace(os.path.sep, '/'))
hou.putenv("FLIP_ROOT", flip_output.replace(os.path.sep, '/'))
hou.putenv("ALEMBIC_ROOT", alembic_output.replace(os.path.sep, '/'))
# create variables for filename output
filename_base = "%s_%s_" % (
(curr_fields.get('Asset')
or curr_fields.get('Shot')), curr_fields.get('task_name'))
filename_version = "_v%s" % str(curr_fields.get('version')).zfill(4)
hou.putenv("FILENAME_ROOT", filename_base)
hou.putenv("FILENAME_VER", filename_version)
import hou
import sinastorage
from haoc import HaocUtils,DBUtils,SCloudUtils
from haoc import HaocEventFilter
hou.putenv("HAOCROOTPATH", HaocUtils.get_root_path())
config = HaocUtils.Config.read()
if not (config.ak=='' or config.sk==''):
sinastorage.setDefaultAppInfo(config.ak,config.sk)
HaocEventFilter.HaocEventF.installHaocEventF()
if DBUtils.is_launch_with_sync():
SCloudUtils.sync_data(False)
