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)
