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 version_dialog():
"""Helper function for version_dialog UI for Nuke
"""
# connect to db
from anima.utils import do_db_setup
do_db_setup()
# set PySide or PySide2
set_qt_lib()
from anima.ui import version_dialog
from anima.env import nukeEnv
import nuke
n = nukeEnv.Nuke()
n.name = "nuke%s.%s" % (nuke.NUKE_VERSION_MAJOR, nuke.NUKE_VERSION_MINOR)
# display only warning messages
import logging
logging.getLogger(version_dialog.__name__).setLevel(logging.WARNING)
logging.getLogger("anima.ui").setLevel(logging.WARNING)
logging.getLogger("anima.ui.models").setLevel(logging.WARNING)
logging.getLogger("anima.env.nuke").setLevel(logging.WARNING)
logging.getLogger("stalker.db").setLevel(logging.WARNING)
version_dialog.UI(environment=n)
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 version_creator(lib='PyQt4', logging_level=logging.WARNING):
"""Helper function for version_creator UI for Fusion
It uses with PySide by default you can opt to use PyQt4 instead by setting
the ``lib`` argument to "PyQt4".
:param str lib: choose a lib, one of ["PySide", "PyQt4"]
:return: None
"""
# connect to db
do_db_setup()
from anima.ui import SET_PYSIDE, SET_PYQT4
if lib == 'PySide':
SET_PYSIDE()
elif lib == 'PyQt4':
SET_PYQT4()
from anima.env import fusion
reload(fusion)
fusion_env = fusion.Fusion()
fusion_env.name = 'Fusion'
from anima.ui import version_creator
logger.setLevel(logging_level)
version_creator.UI(environment=fusion_env)
def version_creator(lib='PySide'):
"""Helper function for version_creator UI for Photoshop
It uses with PySide by default you can opt to use PyQt4 instead by setting
the ``lib`` argument to "PyQt4".
:param str lib: choose a lib, one of ["PySide", "PyQt4"]
:return: None
"""
# connect to db
do_db_setup()
from anima.ui import SET_PYSIDE, SET_PYQT4
if lib == 'PySide':
SET_PYSIDE()
elif lib == 'PyQt4':
SET_PYQT4()
from anima.env import photoshop
reload(photoshop)
p = photoshop.Photoshop()
from anima.ui import version_creator
reload(version_creator)
# display only warning messages
import logging
logging.getLogger(version_creator.__name__).setLevel(logging.WARNING)
logging.getLogger("anima.ui").setLevel(logging.WARNING)
logging.getLogger("anima.ui.models").setLevel(logging.WARNING)
logging.getLogger("anima.env.photoshop").setLevel(
logging.WARNING)
logging.getLogger("stalker.db").setLevel(logging.WARNING)
version_creator.UI(environment=p)
def version_updater(logging_level=logging.WARNING):
"""helper function for version_updater UI for Maya
"""
# connect to db
do_db_setup()
# use PySide for Maya 2014
import pymel
try:
if pymel.versions.current() >= pymel.versions.v2014:
from anima import ui
ui.SET_PYSIDE()
except AttributeError:
pass
from anima.ui import version_updater, models
from anima.env import mayaEnv
reload(mayaEnv)
reload(version_updater)
reload(models)
m = Maya()
m.name = "Maya" + str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
# generate a reference_resolution
version_updater.UI(environment=m)
def version_dialog(lib='PySide', logging_level=logging.WARNING, parent=None):
"""Helper function for version_dialog UI for Fusion
It uses with PySide by default you can opt to use PyQt4 instead by setting
the ``lib`` argument to "PyQt4".
:param str lib: choose a lib, one of ["PySide", "PyQt4"]
:param logging_level:
:return: None
"""
# connect to db
from anima.utils import do_db_setup
do_db_setup()
from anima.ui import SET_PYSIDE, SET_PYQT4
if lib == 'PySide':
SET_PYSIDE()
elif lib == 'PyQt4':
SET_PYQT4()
from anima.env import fusion
reload(fusion)
fusion_env = fusion.Fusion()
fusion_env.name = 'Fusion'
from anima.ui import version_dialog
logger.setLevel(logging_level)
version_dialog.UI(environment=fusion_env, parent=parent)
def version_creator():
"""Helper function for version_creator UI for Houdini
"""
# connect to db
do_db_setup()
import logging
from stalker import log
log.logging_level = logging.WARNING
from anima.ui import version_creator
from anima.env import houdini
reload(houdini)
reload(version_creator)
h = houdini.Houdini()
logger.setLevel(logging.WARNING)
if hou.applicationVersion()[0] <= 13:
version_creator.UI(
environment=h
)
else:
version_creator.UI(
environment=h,
executor=Executor()
)
def __init__(self):
super(MainDialog, self).__init__()
self.setupUi(self)
self.media_files_path = ''
self.cache_file_full_path = os.path.normpath(
os.path.expanduser(
os.path.expandvars(
os.path.join(
anima.local_cache_folder,
anima.avid_media_file_path_storage
)
)
)
)
self.edl_path_lineEdit = LineEdit()
self.formLayout.setWidget(
1,
QtWidgets.QFormLayout.FieldRole,
self.edl_path_lineEdit
)
self.setup_signals()
self.restore_media_file_path()
# connect to database
do_db_setup()
def version_dialog(lib='PySide'):
"""Helper function for version_dialog UI for Photoshop
It uses with PySide by default you can opt to use PyQt4 instead by setting
the ``lib`` argument to "PyQt4".
:param str lib: choose a lib, one of ["PySide", "PyQt4"]
:return: None
"""
# connect to db
do_db_setup()
from anima.ui import SET_PYSIDE, SET_PYQT4
if lib == 'PySide':
SET_PYSIDE()
elif lib == 'PyQt4':
SET_PYQT4()
from anima.env import photoshop
reload(photoshop)
p = photoshop.Photoshop()
from anima.ui import version_dialog
reload(version_dialog)
# display only warning messages
import logging
logging.getLogger(version_dialog.__name__).setLevel(logging.WARNING)
logging.getLogger("anima.ui").setLevel(logging.WARNING)
logging.getLogger("anima.ui.models").setLevel(logging.WARNING)
logging.getLogger("anima.env.photoshop").setLevel(logging.WARNING)
logging.getLogger("stalker.db").setLevel(logging.WARNING)
version_dialog.UI(environment=p)
def __init__(self):
super(MainDialog, self).__init__()
self.setupUi(self)
self.media_files_path = ''
self.cache_file_full_path = os.path.normpath(
os.path.expanduser(
os.path.expandvars(
os.path.join(
anima.local_cache_folder,
anima.avid_media_file_path_storage
)
)
)
)
self.edl_path_lineEdit = LineEdit()
self.formLayout.setWidget(
1,
QtGui.QFormLayout.FieldRole,
self.edl_path_lineEdit
)
self.setup_signals()
self.restore_media_file_path()
# connect to database
do_db_setup()
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 update_outputs():
"""updates outputs in the current script
"""
do_db_setup()
nEnv = nukeEnv.Nuke()
version = nEnv.get_current_version()
if version:
nEnv.create_main_write_node(version)
def version_mover():
"""
"""
# connect to db
do_db_setup()
from anima.ui import version_mover as vm
vm.UI()
def version_mover():
"""
"""
# connect to db
do_db_setup()
from anima.ui import version_mover as vm
vm.UI()
def update_outputs():
"""updates outputs in the current script
"""
do_db_setup()
nEnv = nukeEnv.Nuke()
version = nEnv.get_current_version()
if version:
nEnv.create_main_write_node(version)
def fill_user_names_lut():
"""fills the user_names_lut
"""
if not user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import db, User
map(lambda x: user_names_lut.__setitem__(x[0], x[1]),
db.DBSession.query(User.id, User.name).all())
def range_from_shot(cls):
"""sets the range from the shot
"""
from anima.utils import do_db_setup
do_db_setup()
from anima.env import fusion
fusion_env = fusion.Fusion()
version = fusion_env.get_current_version()
fusion_env.set_range_from_shot(version)
def update_savers(cls):
"""updates savers, creates missing ones
"""
from anima.utils import do_db_setup
do_db_setup()
from anima.env import fusion
fusion_env = fusion.Fusion()
v = fusion_env.get_current_version()
fusion_env.create_main_saver_node(version=v)
def fill_user_names_lut():
"""fills the user_names_lut
"""
if not user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import db, User
map(
lambda x: user_names_lut.__setitem__(x[0], x[1]),
db.DBSession.query(User.id, User.name).all()
)
def user_names_lut(self):
"""fills the _user_names_lut
"""
if not self._user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import User
from stalker.db.session import DBSession
map(lambda x: self._user_names_lut.__setitem__(x[0], x[1]),
DBSession.query(User.id, User.name).all())
return self._user_names_lut
def user_names_lut(self):
"""fills the _user_names_lut
"""
if not self._user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import User
from stalker.db.session import DBSession
for result in DBSession.query(User.id, User.name).all():
self._user_names_lut.__setitem__(result.id, result.name)
return self._user_names_lut
def update_outputs():
"""updates outputs in the current script
"""
from anima.utils import do_db_setup
do_db_setup()
from anima.env import nukeEnv
nEnv = nukeEnv.Nuke()
version = nEnv.get_current_version()
if version:
nEnv.create_main_write_node(version)
def user_names_lut(self):
"""fills the _user_names_lut
"""
if not self._user_names_lut:
from anima.utils import do_db_setup
do_db_setup()
from stalker import User
from stalker.db.session import DBSession
map(
lambda x: self._user_names_lut.__setitem__(x[0], x[1]),
DBSession.query(User.id, User.name).all()
)
return self._user_names_lut
def fill_status_colors_by_id():
"""fills the status_colors_by_id dictionary
"""
if not status_colors_by_id:
from anima.utils import do_db_setup
do_db_setup()
from stalker import StatusList
task_status_list = \
StatusList.query\
.filter(StatusList.target_entity_type == 'Task')\
.first()
for status in task_status_list.statuses:
status_colors_by_id[status.id] = status_colors[status.code.lower()]
def shot_from_range(cls):
"""updates the Shot.cut_in and Shot.cut_out attributes from the current range
"""
from anima.utils import do_db_setup
do_db_setup()
from anima.env import fusion
fusion_env = fusion.Fusion()
version = fusion_env.get_current_version()
try:
fusion_env.set_shot_from_range(version)
except BaseException as e:
QtWidgets.QMessageBox.critical(None, "Error", "%s" % e)
finally:
QtWidgets.QMessageBox.information(None, "Success", "Shot Range has been updated successfully!")
def fill_status_colors_by_id():
"""fills the status_colors_by_id dictionary
"""
if not status_colors_by_id:
from anima.utils import do_db_setup
do_db_setup()
from stalker import StatusList
task_status_list = \
StatusList.query\
.filter(StatusList.target_entity_type == 'Task')\
.first()
for status in task_status_list.statuses:
status_colors_by_id[status.id] = status_colors[status.code.lower()]
def project_manager(logging_level=logging.WARNING):
"""Helper function for project_manager 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 project_manager
from anima.env import mayaEnv
# set the parent object to the maya main window
project_manager.ui_caller(None, None, project_manager.MainWindow)
def project_manager(logging_level=logging.WARNING):
"""Helper function for project_manager 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 project_manager
from anima.env import mayaEnv
# set the parent object to the maya main window
project_manager.ui_caller(None, None, project_manager.MainWindow)
def version_creator(cls, **args):
"""version creator
"""
# from anima.ui.scripts import fusion
# fusion.version_creator(*args)
from anima.utils import do_db_setup
do_db_setup()
from anima.env import fusion
fusion_env = fusion.Fusion()
fusion_env.name = 'Fusion'
from anima.ui import version_creator
ui_instance = version_creator.MainDialog(environment=fusion_env,
**args)
ui_instance.show()
ui_instance.center_window()
def version_creator(logging_level=logging.WARNING):
"""Helper function for version_creator UI for MotionBuilder
"""
# connect to db
from anima.utils import do_db_setup
do_db_setup()
# set Qt library
set_qt_lib()
from anima.ui import version_creator
from anima.env import motion_builder
mb = motion_builder.MotionBuilder()
logger.setLevel(logging_level)
version_creator.UI(environment=mb)
def version_creator(logging_level=logging.WARNING):
"""Helper function for version_creator UI for MotionBuilder
"""
# connect to db
from anima.utils import do_db_setup
do_db_setup()
# set Qt library
set_qt_lib()
from anima.ui import version_creator
from anima.env import motion_builder
mb = motion_builder.MotionBuilder()
logger.setLevel(logging_level)
version_creator.UI(environment=mb)
def version_updater():
"""Helper function for version_updater UI for Max
"""
from anima.utils import do_db_setup
do_db_setup()
from anima import ui
ui.SET_PYSIDE()
from anima.ui import version_updater
from anima.env import max as max_env
m = max_env.Max()
import MaxPlus
max_window = MaxPlus.GetQMaxWindow()
version_updater.UI(environment=m, executor=Executor(), parent=max_window)
def __init__(self, *args, **kwargs):
super(MainDialog, self).__init__(*args, **kwargs)
self.resolve = blackmagic.get_resolve()
self.project = self.resolve.GetProjectManager().GetCurrentProject()
xml_path = tempfile.gettempdir()
xml_file_name = 'conformer___temp__1.8_fcpxml.fcpxml'
xml_file_path = os.path.join(xml_path, xml_file_name)
self.xml_path = xml_file_path
do_db_setup()
self._setup_ui()
self._setup_signals()
self._set_defaults()
def version_dialog(logging_level=logging.WARNING):
"""Helper function for version_dialog UI for Maya
"""
# connect to db
from anima.utils import do_db_setup
do_db_setup()
# use PySide2
from anima import ui
ui.SET_PYSIDE2()
from anima.ui import version_dialog
from anima.env import blender as blender_env
b = blender_env.Blender()
logger.setLevel(logging_level)
# set the parent object to the maya main window
version_dialog.UI(environment=b, parent=None)
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 PySide2
from anima import ui
ui.SET_PYSIDE2()
from anima.ui import version_dialog
from anima.env import equalizer
e = equalizer.Equalizer()
e.name = tde4.get3DEVersion().split(" ")[0]
logger.setLevel(logging_level)
# set the parent object to the maya main window
version_dialog.UI(environment=e, mode=mode)
def version_updater(logging_level=logging.WARNING):
"""helper function for version_updater UI for Maya
"""
# connect to db
do_db_setup()
# set Qt lib
set_qt_lib()
from anima.ui import version_updater, models
from anima.env import mayaEnv
reload(mayaEnv)
reload(version_updater)
reload(models)
m = Maya()
import pymel
m.name = "Maya" + str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
# generate a reference_resolution
version_updater.UI(environment=m)
def version_creator(logging_level=logging.WARNING):
"""Helper function for version_creator UI for Maya
"""
# connect to db
do_db_setup()
# use PySide for Maya 2014
set_qt_lib()
from anima.ui import version_creator, models
from anima.env import mayaEnv
reload(version_creator)
reload(models)
reload(mayaEnv)
m = Maya()
import pymel
m.name = "Maya%s" % str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
version_creator.UI(environment=m)
def version_updater():
"""Helper function for version_updater UI for Max
"""
from anima.utils import do_db_setup
do_db_setup()
from anima import ui
ui.SET_PYSIDE()
from anima.ui import version_updater
from anima.env import max as max_env
m = max_env.Max()
import MaxPlus
max_window = MaxPlus.GetQMaxWindow()
version_updater.UI(
environment=m,
executor=Executor(),
parent=max_window
)
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 version_creator(logging_level=logging.WARNING):
"""Helper function for version_creator UI for Maya
"""
# connect to db
do_db_setup()
# use PySide for Maya 2014
set_qt_lib()
from anima.ui import version_creator, models
from anima.env import mayaEnv
reload(version_creator)
reload(models)
reload(mayaEnv)
m = Maya()
import pymel
m.name = "Maya%s" % str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
version_creator.UI(environment=m)
def version_updater(logging_level=logging.WARNING):
"""helper function for version_updater UI for Maya
"""
# connect to db
do_db_setup()
# set Qt lib
set_qt_lib()
from anima.ui import version_updater, models
from anima.env import mayaEnv
reload(mayaEnv)
reload(version_updater)
reload(models)
m = Maya()
import pymel
m.name = "Maya" + str(pymel.versions.current())[0:4]
logger.setLevel(logging_level)
# generate a reference_resolution
version_updater.UI(environment=m)
def version_creator():
"""Helper function for version_creator UI for Houdini
"""
# connect to db
do_db_setup()
import logging
from stalker import log
log.logging_level = logging.WARNING
from anima.ui import version_creator
from anima.env import houdini
reload(houdini)
reload(version_creator)
h = houdini.Houdini()
logger.setLevel(logging.WARNING)
if hou.applicationVersion()[0] <= 13:
version_creator.UI(environment=h)
else:
version_creator.UI(environment=h, executor=Executor())
def version_creator():
"""Helper function for version_creator UI for Nuke
"""
# connect to db
do_db_setup()
# set PySide or PySide2
set_qt_lib()
from anima.ui import version_creator
from anima.env import nukeEnv
n = nukeEnv.Nuke()
n.name = "Nuke"
# display only warning messages
import logging
logging.getLogger(version_creator.__name__).setLevel(logging.WARNING)
logging.getLogger("anima.ui").setLevel(logging.WARNING)
logging.getLogger("anima.ui.models").setLevel(logging.WARNING)
logging.getLogger("anima.env.nuke").setLevel(logging.WARNING)
logging.getLogger("stalker.db").setLevel(logging.WARNING)
version_creator.UI(environment=n)
def version_creator():
"""Helper function for version_creator UI for Nuke
"""
# connect to db
do_db_setup()
# set PySide or PySide2
set_qt_lib()
from anima.ui import version_creator
from anima.env import nuke_studioEnv
ns = nuke_studioEnv.NukeStudio()
ns.name = "NukeStudio"
# display only warning messages
import logging
logging.getLogger(version_creator.__name__).setLevel(logging.WARNING)
logging.getLogger("anima.ui").setLevel(logging.WARNING)
logging.getLogger("anima.ui.models").setLevel(logging.WARNING)
logging.getLogger("anima.env.nuke_studioEnv").setLevel(logging.WARNING)
logging.getLogger("stalker.db").setLevel(logging.WARNING)
version_creator.UI(environment=ns)
def version_creator():
"""Helper function for version_creator UI for Nuke
"""
# connect to db
do_db_setup()
# use PySide
from anima import ui
ui.SET_PYSIDE()
from anima.ui import version_creator
from anima.env import nukeEnv
n = nukeEnv.Nuke()
n.name = "Nuke"
# display only warning messages
import logging
logging.getLogger(version_creator.__name__).setLevel(logging.WARNING)
logging.getLogger("anima.ui").setLevel(logging.WARNING)
logging.getLogger("anima.ui.models").setLevel(logging.WARNING)
logging.getLogger("anima.env.nuke").setLevel(logging.WARNING)
logging.getLogger("stalker.db").setLevel(logging.WARNING)
version_creator.UI(environment=n)
def register():
"""register the addon
"""
# do database setup
from anima.utils import do_db_setup
do_db_setup()
#
# generate one class for each menu item
#
# This is a limitation of Blender, as of 2.71 the ``layout.menu()`` method
# is not returning any item to set the property to, so clever guys around
# the blender community are suggesting to dynamically generating new
# classes which is a very very very very bad practice, which essentially
# does nothing better than bloating the python name space.
#
for project in Project.query.order_by(Project.name).all():
opclass = generate_op_class(
project,
draw=draw_stalker_project_menu_item
)
bpy.utils.register_class(opclass)
# append them to the lookup table so we will be able to unregister
# them later on
registered_menus.append(opclass)
# for each project register a sequence menu
all_seqs = Sequence.query.\
filter(Sequence.project == project)\
.order_by(Sequence.name).all()
for seq in all_seqs:
opclass = generate_op_class(
seq,
draw=draw_stalker_sequence_menu_item
)
bpy.utils.register_class(opclass)
registered_menus.append(opclass)
# for each sequence register a scene menu
for sce in seq.children:
opclass = generate_op_class(
sce,
draw=draw_stalker_scene_menu_item
)
bpy.utils.register_class(opclass)
registered_menus.append(opclass)
# generate a "Add From Shots" menu for each of them
opclass = generate_op_class(
sce,
draw=draw_stalker_scene_add_from_shots_menu_item,
idpostfix='_add_from_shots_menu',
label='Add From Shots'
)
bpy.utils.register_class(opclass)
registered_menus.append(opclass)
# for each Shot generate a menu item
for shot in Shot.query.filter(Shot.project == project).all():
opclass = generate_op_class(
shot,
draw=draw_stalker_shot_menu_item
)
bpy.utils.register_class(opclass)
registered_menus.append(opclass)
bpy.utils.register_class(StalkerMenu)
bpy.utils.register_class(StalkerAddFromProjectMenu)
bpy.utils.register_class(StalkerSceneAddEverythingOperator)
bpy.utils.register_class(StalkerSceneAddStoryboardOperator)
bpy.utils.register_class(StalkerSceneAddPrevisOperator)
bpy.utils.register_class(StalkerSceneAddAllShotOutputsOperator)
bpy.utils.register_class(StalkerSceneAddAllShotPrevisOutputsOperator)
bpy.utils.register_class(StalkerSceneAddAllShotAnimationOutputsOperator)
bpy.utils.register_class(StalkerSceneAddAllShotLightingOutputsOperator)
bpy.utils.register_class(StalkerSceneAddAllShotCompOutputsOperator)
bpy.utils.register_class(StalkerShotAddAllTaskOutputsOperator)
bpy.utils.register_class(StalkerShotAddPrevisOutputOperator)
bpy.utils.register_class(StalkerShotAddAnimationOutputOperator)
bpy.utils.register_class(StalkerShotAddLightingOutputOperator)
bpy.utils.register_class(StalkerShotAddCompOutputOperator)
bpy.types.SEQUENCER_MT_add.append(draw_stalker_menu)
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 setup_db(cls):
"""setup the db
"""
from anima.utils import do_db_setup
do_db_setup()
