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)