def create_representations(): """creates the representations of the scene """ from anima.env import mayaEnv m_env = mayaEnv.Maya() v = m_env.get_current_version() if not v: return if Representation.repr_separator in v.take_name: return # skip if it is a Character skip_types = ['character', 'animation', 'previs', 'vehicle'] for t in v.naming_parents: for st in skip_types: if t.type and t.type.name.lower().startswith(st): return from anima.env.mayaEnv import repr_tools gen = repr_tools.RepresentationGenerator(version=v) gen.generate_all() # re-open the original scene m_env = mayaEnv.Maya() current_version = m_env.get_current_version() if current_version != v: m_env.open(v, force=True, skip_update_check=True)
def generate_job_name(cls): """generates a job name according to the current scene """ # first check if it is a Stalker Project from anima.env import mayaEnv m = mayaEnv.Maya() v = m.get_current_version() if v is not None: from stalker import Version assert isinstance(v, Version) return '%s:%s_v%03i%s' % ( v.task.project.code, v.nice_name, v.version_number, v.extension ) try: # check if it is a oyProjectManager job from oyProjectManager.environments import mayaEnv m = mayaEnv.Maya() v = m.get_current_version() if v is not None: from oyProjectManager.models.version import Version assert isinstance(v, Version) # get asset or shot versionable = v.version_of from oyProjectManager.models.asset import Asset from oyProjectManager.models.shot import Shot first_part = None if isinstance(versionable, Asset): first_part = '%s:%s' % ( versionable.project.code, versionable.code ) elif isinstance(versionable, Shot): first_part = '%s:%s' % ( versionable.project.code, versionable.sequence.code ) return '%s:%s' % ( first_part, '%s_%s_%s_v%03i_%s%s' % ( v.base_name, v.take_name, v.type.code, v.version_number, v.created_by.initials, v.extension ) ) except ImportError: return os.path.basename(pm.sceneName())
def fix_reference_paths(cls): """Fixes reference paths that are not using environment vars """ # list current scene references from anima.env import mayaEnv m_env = mayaEnv.Maya() current_version = m_env.get_current_version() all_refs = pm.listReferences(recursive=True) refs_with_wrong_prefix = [] for ref in all_refs: if '$REPO' not in ref.unresolvedPath(): parent = ref.parent() if parent: refs_with_wrong_prefix.append(parent) ref_paths = [ref.path for ref in refs_with_wrong_prefix] for ref_path in ref_paths: version = m_env.get_version_from_full_path(ref_path) if version: m_env.open(version, force=True, skip_update_check=True) pm.saveFile() if pm.env.sceneName() != current_version.absolute_full_path: m_env.open(current_version, force=True, skip_update_check=True)
def version_updater(logging_level=logging.WARNING): """helper function for version_updater UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # set Qt lib set_qt_lib() from anima.ui import version_updater from anima.env import mayaEnv m = mayaEnv.Maya() import pymel m.name = "Maya%s" % str(pymel.versions.current())[0:4] logger.setLevel(logging_level) # generate a reference_resolution # global version_updater_dialog # if version_updater_dialog is None: # version_updater_dialog = version_updater.UI(environment=m) # else: # version_updater_dialog.show() # set the parent object to the maya main window version_updater.UI(environment=m, parent=mayaEnv.get_maya_main_window())
def version_creator(logging_level=logging.WARNING): """Helper function for version_creator UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # use PySide for Maya 2014 # and PySide2 for Maya 2017 set_qt_lib() from anima.ui import version_creator from anima.env import mayaEnv m = mayaEnv.Maya() import pymel m.name = "Maya%s" % str(pymel.versions.current())[0:4] logger.setLevel(logging_level) # global version_creator_dialog # if version_creator_dialog is None: # version_creator_dialog = version_creator.UI(environment=m) # else: # version_creator_dialog.show() # set the parent object to the maya main window version_creator.UI(environment=m, parent=mayaEnv.get_maya_main_window())
def bind_to_original(cls): """binds the current scene references to original references from the repository """ # get all reference paths import os from anima.env import mayaEnv from stalker import Repository, Version, Task m = mayaEnv.Maya() current_version = m.get_current_version() # get the current project project = None if current_version: project = current_version.task.project # no project then do nothing if project: for ref in pm.listReferences(): unresolved_path = ref.unresolvedPath() filename = os.path.basename(unresolved_path) # find the corresponding version v = Version.query\ .join(Version.task, Task.versions)\ .filter(Task.project == project)\ .filter(Version.full_path.endswith(filename)).first() if v: ref.replaceWith( Repository.to_os_independent_path( v.absolute_full_path ) )
def fix_reference_namespace(cls): """fixes reference namespace """ ref_count = len(pm.listReferences(recursive=True)) if ref_count > 25: result = pm.windows.confirmBox( 'Fix Reference Namespace', 'You have %s references in your scene,\n' 'this will take too much time\n\nIs that Ok?' % ref_count ) if not result: return from stalker import LocalSession from anima.env import mayaEnv m = mayaEnv.Maya() local_session = LocalSession() logged_in_user = local_session.logged_in_user if not logged_in_user: raise RuntimeError('Please login before running the script') versions = m.fix_reference_namespaces() for version in versions: version.created_by = logged_in_user from stalker.db.session import DBSession DBSession.commit()
def save_previs_to_shots(cls): """exports previs to animation shots """ from anima.env import mayaEnv from anima.env.mayaEnv import previs se = previs.ShotExporter() # use previs scene take_name m = mayaEnv.Maya() v = m.get_current_version() se.save_previs_to_shots(v.take_name)
def __init__(self): self.working_file_name = pm.env.sceneName() self.working_scene_name = os.path.basename(pm.env.sceneName()) self.working_folder = pm.workspace(fn=True) self.sm = pm.ls('sequenceManager1')[0] self.sequencer = self.sm.sequences.get()[0] self.shot_list = self.sequencer.shots.get() self.m_env = mayaEnv.Maya()
def update_shot_range(): """update shot range """ from stalker import db, Shot from anima.env import mayaEnv m = mayaEnv.Maya() v = m.get_current_version() shot = v.task.parent if shot and isinstance(shot, Shot): shot_node = pm.ls(type='shot')[0] start_frame = shot_node.startFrame.get() end_frame = shot_node.endFrame.get() shot.cut_in = int(start_frame) shot.cut_out = int(end_frame) db.DBSession.commit()
def update_audit_info(): """updates the audit info of the version """ from stalker import LocalSession local_session = LocalSession() logged_in_user = local_session.logged_in_user if logged_in_user: # update the version updated_by from anima.env import mayaEnv m_env = mayaEnv.Maya() v = m_env.get_current_version() if v: v.updated_by = logged_in_user from stalker import db db.DBSession.commit()
def publish_checker(cls): """Opens the Publish Checker window without publishing the current scene """ import functools from anima.env import mayaEnv m = mayaEnv.Maya() version = m.get_current_version() # create the publish window from anima.ui import publish_checker dialog = publish_checker.UI(environment=m, publish_callback=None, version=version, parent=mayaEnv.get_maya_main_window()) dialog.auto_delete_new_version_on_exit = False dialog.show()
def export_camera(): """exports camera and the related shot node """ from stalker import Task, Version from anima.env import mayaEnv m = mayaEnv.Maya() v = m.get_current_version() shot = pm.ls(type='shot')[0] try: sequencer = pm.ls(shot.message.connections(), type='sequencer')[0] except IndexError: sequencer = None camera = None if shot: camera = shot.currentCamera.get() camera_task = \ Task.query\ .filter(Task.parent == v.task.parent)\ .filter(Task.name == 'Camera').first() if camera_task: from stalker import LocalSession local_session = LocalSession() logged_in_user = local_session.logged_in_user cam_v = Version(task=camera_task, description='Exported from %s task on Publish' % v.task.name) cam_v.update_paths() cam_v.extension = '.ma' cam_v.is_published = True cam_v.created_by = cam_v.updated_by = logged_in_user pm.select([shot, camera, sequencer]) m.export_as(cam_v)
def export_alembics(path): """Creates alembic files :param str path: The path of the file version :return: """ from anima.env import mayaEnv m = mayaEnv.Maya() m.use_progress_window = False # Maya sets that automatically but let's be sure! v = m.get_version_from_full_path(path) if not v: raise RuntimeError("version not found!") m.open(v, force=True, skip_update_check=True, prompt=False) from anima.env.mayaEnv import animation animation.Animation.set_range_from_shot() from anima.env.mayaEnv import auxiliary auxiliary.export_alembic_from_cache_node(handles=1, isolate=False, unload_refs=False) print("Alembic Export Done!")
def export_playblast(path): """Playblasts the current scene :param str path: The path of the file version :return: """ import pymel.core as pm from anima.env import mayaEnv m = mayaEnv.Maya() m.use_progress_window = False # Maya sets that automatically but let's be sure! v = m.get_version_from_full_path(path) if not v: raise RuntimeError("version not found!") m.open(v, force=True, skip_update_check=True, prompt=False) from anima.env.mayaEnv import animation animation.Animation.set_range_from_shot() # delete any focusPlane shape nodes to prevent them from being shown in the playblast pm.delete(pm.ls("focusPlane*Shape")) shots = pm.ls(type='shot') if shots: shot = shots[0] camera = None if shot: camera = pm.PyNode(shot.getCurrentCamera()) # set only the camera renderable and the rest non renderable for cam in pm.ls(type='camera'): cam.renderable.set(0) if camera: camera.renderable.set(1) from anima.env.mayaEnv import auxiliary default_view_options = auxiliary.get_default_playblast_view_options() auxiliary.perform_playblast(0, resolution=100, playblast_view_options=default_view_options, upload_to_server=True) print("Playblast Done!")
def version_dialog(logging_level=logging.WARNING, mode=2): """Helper function for version_dialog UI for Maya """ # connect to db from anima.utils import do_db_setup do_db_setup() # use PySide for Maya 2014 # and PySide2 for Maya 2017 set_qt_lib() from anima.ui import version_dialog from anima.env import mayaEnv m = mayaEnv.Maya() import pymel m.name = "Maya%s" % str(pymel.versions.current())[0:4] logger.setLevel(logging_level) # set the parent object to the maya main window version_dialog.UI(environment=m, parent=mayaEnv.get_maya_main_window(), mode=mode)
def set_range_from_shot(cls): """sets the playback range from a shot node in the scene """ shots = pm.ls(type='shot') min_frame = None max_frame = None if shots: # use the available shot node shot = shots[0] min_frame = shot.getAttr('startFrame') max_frame = shot.getAttr('endFrame') else: # check if this is a shot related scene from anima.env import mayaEnv m = mayaEnv.Maya() v = m.get_current_version() if v: t = v.task from stalker import Shot parents = t.parents parents.reverse() for p in parents: if isinstance(p, Shot): pm.warning('No shot node in the scene, ' 'using the Shot task!!!') min_frame = p.cut_in max_frame = p.cut_out break if min_frame is not None and max_frame is not None: pm.playbackOptions(ast=min_frame, aet=max_frame, min=min_frame, max=max_frame) else: pm.error( 'No shot node in the scene, nor the task is related to a Shot!' )
def __init__(self): from anima.utils import do_db_setup from stalker import Type, LocalSession from anima.env import mayaEnv do_db_setup() m = mayaEnv.Maya() local_session = LocalSession() self.logged_in_user = local_session.logged_in_user if not self.logged_in_user: raise RuntimeError('Please login to Stalker') if not m.get_current_version(): raise RuntimeError('This scene is not saved with Stalker') self.anim_type = Type.query.filter(Type.name == "Animation").first() self.prev_type = Type.query.filter(Type.name == "Previs").first() # get current task info self.current_version = m.get_current_version() self.current_task = self.current_version.task self.current_type = self.current_task.type # check task type if self.current_type not in [self.anim_type, self.prev_type]: raise RuntimeError( 'Task must be either an Animation or Previs Task.') # query sequenceManager if len(pm.ls(type='sequenceManager')) is not 1: raise RuntimeError('There must be just 1 sequenceManager.') self.sm = pm.ls('sequenceManager1')[0] # query sequencer seqs = [ seq for seq in pm.ls(type='sequencer') if seq.referenceFile() is None ] if len(seqs) is not 1: raise RuntimeError('There must be just 1 sequencer.') self.sequencer = self.sm.sequences.get()[0] # query all shots in sequencer self.shot_list = self.sequencer.shots.get() # query shots in time based descending order shots = self.shot_list shots_sorted = [] shots_mid_frames = [] mid_frames = [] for shot in shots: start = shot.getSequenceStartTime() end = shot.getSequenceEndTime() mid_frame = int(start + ((end - start) / 2)) shots_mid_frames.append([shot, mid_frame]) mid_frames.append(mid_frame) mid_frames.sort() inc = -1 for frame in mid_frames: inc += 1 for shot in shots_mid_frames: if frame == shot[1]: if shot[0] not in shots_sorted: shots_sorted.append(shot[0]) self.shots_descending = shots_sorted # query all shot tasks from current scene shot_task = None parent_task = None if self.current_type is self.prev_type: parent_task = self.current_task.parent elif self.current_type is self.anim_type: parent_task = self.current_task.parent.parent if parent_task is None: raise RuntimeError('Current Task does not have Proper Parents.') for task in parent_task.walk_hierarchy(): if task.nice_name == 'Shots': shot_task = task break if shot_task is None: raise RuntimeError('Shots Task can not be found.') self.scene_shot_tasks = shot_task.tasks
def save_previs_to_shots(self, take_name): """exports previs to animation shots """ self.pre_publish_previs() shot_tasks = self.scene_shot_tasks shot_nodes = self.shot_list shots_to_export = [] for shot_node in shot_nodes: for shot_task in shot_tasks: for task in shot_task.tasks: if task.type == self.anim_type: shot_number = shot_task.name.split('_')[-1] if shot_node.getShotName() == shot_number: shots_to_export.append( [shot_node, task, shot_number]) from anima.env import mayaEnv from stalker import Version from anima.ui.progress_dialog import ProgressDialogManager pdm = ProgressDialogManager() pdm.close() m_env = mayaEnv.Maya() versions = [] description = 'Auto Created By Shot Exporter' # create versions to save and show in pop-up window for shot_info in shots_to_export: version = Version(task=shot_info[1], description=description, take_name=take_name, created_by=self.logged_in_user) versions.append(version) if len(versions) != len(shots_to_export): from stalker.db.session import DBSession DBSession.rollback() raise RuntimeError( 'Something is critically wrong. Contact Mehmet ERER.') # pop-up a window to show everything will be saved properly before actually doing it message = 'Shots will be Saved as Below:\r\n' message += '\r' index = 0 for shot_info in shots_to_export: v = versions[index] message += 'shot[ %s ] -> %s\n' % (shot_info[2], v) index += 1 dialog = pm.confirmDialog( title='Important Warning', message=message, button=['OK, Start Saving Shots', 'STOP, wrong paths!']) if dialog == 'OK, Start Saving Shots': pass else: from stalker.db.session import DBSession DBSession.rollback() raise RuntimeError('Process Interrupted by User.') previs_version = self.current_version errored_shots = [] ind = 0 caller = pdm.register( len(shots_to_export), 'Batch Saving Previs Shot Nodes to Animation Shot Tasks...') from anima.env.mayaEnv import toolbox from stalker.db.session import DBSession for shot_info in shots_to_export: shot_task = versions[ind].task.parent try: # open previs version m_env.open(previs_version, force=True, reference_depth=3, skip_update_check=True) # clear scene except_this_shot = pm.PyNode(shot_info[0].name()) self.clear_scene(except_this_shot) # set frame range before save anima.env.mayaEnv.animation.Animation.set_range_from_shot() # update shot.cut_in and shot.cut_out info cut_in = pm.playbackOptions(q=1, min=1) cut_out = pm.playbackOptions(q=1, max=1) shot_task.cut_in = int(cut_in) shot_task.cut_out = int(cut_out) # save it m_env.save_as(versions[ind]) except: errored_shots.append(shot_info[2]) else: # store information to database DBSession.add(shot_task) DBSession.add(versions[ind]) DBSession.commit() ind += 1 caller.step() if errored_shots: message = 'Shots could not be saved:\r\n' message += '\r' for shot in errored_shots: message += '[ %s ]\n' % shot pm.confirmDialog(title='Error', message=message, button='OK') DBSession.rollback() raise RuntimeError( 'Some Shots could not be saved. Contact Mehmet ERER.') # leave it as empty new file pm.newFile(force=True) message = 'Previs to Shots\r\n' message += '\r' message += 'Completed Succesfully.\r\n' pm.confirmDialog(title='Info', message=message, button='OK')
def publish_model_as_look_dev(cls): """Publishes Model versions as LookDev versions of the same task. Also handles references etc. """ # # Create LookDev for Current Model Task # from stalker import Task, Version, Type, LocalSession from stalker.db.session import DBSession from anima import defaults from anima.env import mayaEnv do_db_setup() m = mayaEnv.Maya() local_session = LocalSession() logged_in_user = local_session.logged_in_user if not logged_in_user: raise RuntimeError('Please login to Stalker') model_type = Type.query.filter(Type.name=="Model").first() look_dev_type = \ Type.query.filter(Type.name=="Look Development").first() current_version = m.get_current_version() model_task = current_version.task if model_task.type != model_type: raise RuntimeError('This is not a Model version') if not current_version.is_published: raise RuntimeError('Please Publish this maya scene') if current_version.take_name != 'Main': raise RuntimeError('This is not the Main take') # find lookDev look_dev = Task.query\ .filter(Task.parent == model_task.parent)\ .filter(Task.type == look_dev_type).first() if not look_dev: raise RuntimeError( 'There is no LookDev task, please inform your Stalker admin' ) previous_look_dev_version = \ Version.query\ .filter(Version.task == look_dev)\ .filter(Version.take_name == 'Main')\ .first() description = 'Auto Created By %s ' % logged_in_user.name take_name = defaults.version_take_name if not previous_look_dev_version: # do the trick pm.newFile(f=1) # create a new version new_version = Version( task=look_dev, description=description, take_name=take_name, created_by=logged_in_user ) new_version.is_published = True m.save_as(new_version) # reference the model version pm.createReference( current_version.absolute_full_path, gl=True, namespace=current_version.nice_name, options='v=0' ) pm.saveFile() DBSession.add(new_version) else: latest_look_dev_version = previous_look_dev_version.latest_version reference_resolution = m.open(latest_look_dev_version, force=True, skip_update_check=True) m.update_versions(reference_resolution) if reference_resolution['update'] \ or reference_resolution['create']: # create a new version new_version = Version( task=look_dev, description=description, take_name=take_name, created_by=logged_in_user, parent=latest_look_dev_version ) new_version.is_published = True m.save_as(new_version) # reopen model scene m.open(current_version, force=True, skip_update_check=True)