def startDrag(self, event):
if not self.parent.pin:
logger.warning(
"Please 'pin' an asset before importing something...")
elif not self.parent.selected_asset.stage:
logger.warning("Must import a stage...")
else:
assets_list = []
asset = copy.deepcopy(self.parent.selected_asset)
default_variant = prefs.asset(asset).stage.default_variant
variants_list = prefs.asset(asset).stage.variants
variants_list.remove(default_variant)
asset.variant = default_variant
exported_assets_list = prefs.asset(
asset).export_root.exported_assets_list
if exported_assets_list != []:
for exported_asset in exported_assets_list:
asset.export_asset = exported_asset
asset.export_version = prefs.asset(
asset).export.last_version
asset.software = prefs.asset(asset).export.version_software
if asset.export_version:
string_asset = utils.asset_to_string(asset)
assets_list.append(string_asset)
if assets_list == []:
for variant in variants_list:
asset.variant = variant
exported_assets_list = prefs.asset(
asset).export_root.exported_assets_list
if exported_assets_list != []:
for exported_asset in exported_assets_list:
asset.export_asset = exported_asset
asset.export_version = prefs.asset(
asset).export.last_version
asset.software = prefs.asset(
asset).export.version_software
if asset.export_version:
string_asset = utils.asset_to_string(asset)
assets_list.append(string_asset)
break
if assets_list != []:
mimeData = QtCore.QMimeData()
mimeData.setText((pickle.dumps(assets_list, 0)).decode())
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
icon = defaults._nodes_icons_dic_[
self.parent.selected_asset.stage]
pixmap = QtGui.QPixmap(icon).scaled(
38, 38, QtCore.Qt.KeepAspectRatio,
QtCore.Qt.SmoothTransformation)
drag.setPixmap(pixmap)
drag.setHotSpot(
QtCore.QPoint(pixmap.width() / 2, pixmap.height()))
drag.setPixmap(pixmap)
result = drag.exec_(QtCore.Qt.MoveAction)
else:
logger.warning("No publish found...")
def playblast(self):
if self.out_range:
if self.asset.software == defaults._maya_ or self.asset.software == defaults._maya_yeti_ or self.asset.software == defaults._houdini_:
show_ornaments = self.ui.playblast_ornaments_checkBox.isChecked(
)
show_playblast = self.ui.playblast_show_checkBox.isChecked()
items_list = self.ui.export_ma_assets_listWidget.selectedItems(
)
refresh_assets = self.ui.export_m_refresh_assets_checkBox.isChecked(
)
nspace_list = []
for item in items_list:
nspace_list.append(item.text())
if (len(nspace_list) == 1) or (len(nspace_list) == 0):
env_path = os.path.abspath('softwares_env').replace(
'\\', '/')
if nspace_list != []:
camera = nspace_list[-1]
else:
camera = None
command = 'import sys\nsys.path.append("{}")\n'.format(
env_path)
command += 'from wizard.tools.playblast import playblast\n'
command += 'playblast("{}", {}, {}, is_preroll={}).playblast("{}", {}, {})'.format(
utils.asset_to_string(self.asset), self.out_range,
refresh_assets, self.is_preroll, camera,
show_ornaments, show_playblast)
file = utils.temp_file_from_command(command)
python_system = 'pywizard'
if sys.argv[0].endswith('.py'):
python_system = 'python'
env = os.environ.copy()
env[defaults._asset_var_] = utils.asset_to_string(
self.asset)
self.ui_subprocess_manager = ui_subprocess_manager.Main(
"{} {}".format(python_system, file), env)
build.launch_normal_as_child(self.ui_subprocess_manager,
minimized=1)
self.hide()
else:
logger.warning("Please select one camera")
else:
logger.warning("Please enter a valid frame range")
def copy_references(references_list):
clipboard_data = get_clipboard_data()
string_refs_list = []
for asset in references_list:
string_refs_list.append(utils.asset_to_string(asset))
clipboard_data[defaults._clipboard_reference_list_] = string_refs_list
write_clipboard(clipboard_data)
def save():
asset = asset_core.string_to_asset(os.environ[defaults._asset_var_])
asset.version = prefs().asset(asset).software.get_new_version()
Document().save(asset.file)
string_asset = utils.asset_to_string(asset)
os.environ[defaults._asset_var_] = string_asset
send_signal.save_request_signal(asset.file, string_asset)
def build_scene(self):
os.environ[defaults._asset_var_] = utils.asset_to_string(
self.cfx_asset)
cmds.file(f=True, new=True)
reference_asset.import_anim()
reference_asset.import_hair()
cmds.file(rename=self.cfx_scene)
cmds.file(save=True, type='mayaAscii', f=True)
def execute(self):
file = utils.temp_file_from_command(self.command)
hython = prefs.software(defaults._hython_).path
env = software.get_env(defaults._hython_, 0)
env[defaults._asset_var_] = utils.asset_to_string(self.asset)
self.ui_subprocess_manager = ui_subprocess_manager.Main([hython, "-u", file], env)
build.launch_normal_as_child(self.ui_subprocess_manager, minimized = 1)
def save():
'''Save file in an incremental version.'''
asset = asset_core.string_to_asset(os.environ[defaults._asset_var_])
asset.version = prefs.asset(asset).software.get_new_version()
bpy.ops.wm.save_as_mainfile(filepath=asset.file)
logger.info('File saved.')
string_asset = utils.asset_to_string(asset)
os.environ[defaults._asset_var_] = string_asset
send_signal.save_request_signal(asset.file, string_asset)
def save():
asset = asset_core.string_to_asset(os.environ[defaults._asset_var_])
asset.version = prefs.asset(asset).software.get_new_version()
if os.path.isfile(asset.file):
asset.version = str(int(asset.version) + 1).zfill(4)
cmds.file(rename=asset.file)
cmds.file(save=True, type='mayaAscii')
string_asset = utils.asset_to_string(asset)
os.environ[defaults._asset_var_] = string_asset
send_signal.save_request_signal(asset.file, string_asset)
def execute(self):
if self.command != '':
file = utils.temp_file_from_command(self.command)
mayapy = prefs.software(defaults._mayapy_).path
env = software.get_env(defaults._mayapy_, 0)
env[defaults._asset_var_] = utils.asset_to_string(self.asset)
self.ui_subprocess_manager = ui_subprocess_manager.Main([mayapy, "-u", file], env)
build.launch_normal_as_child(self.ui_subprocess_manager, minimized = 1)
else:
logger.warning('Nothing to export !')
def __init__(self, asset):
super(Main, self).__init__()
# Build the ui from ui converted file
self.ui = Ui_Form()
self.ui.setupUi(self)
self.asset = asset
self.string_asset = utils.asset_to_string(asset)
self.widgets_list = []
self.init_ui()
self.connect_functions()
self.hidden = 0
def do_playblast_1(self):
if self.asset:
if self.asset.software == defaults._maya_ or self.asset.software == defaults._maya_yeti_:
command = 'from wizard.tools.playblast import playblast/n'
command += 'playblast("{}").playblast()'.format(
utils.asset_to_string(self.asset))
file = utils.temp_file_from_command(command)
self.ui_subprocess_manager = ui_subprocess_manager.Main(
["python", "-u", file])
build.launch_normal_as_child(self.ui_subprocess_manager,
minimized=1)
def save():
asset = asset_core.string_to_asset(os.environ[defaults._asset_var_])
asset.version = prefs.asset(asset).software.get_new_version()
if os.path.isfile(asset.file):
asset.version = str(int(asset.version) + 1).zfill(4)
nuke.scriptSaveAs(asset.file)
string_asset = utils.asset_to_string(asset)
os.environ[defaults._asset_var_] = string_asset
send_signal.save_request_signal(asset.file, string_asset)
def batch_export_maya(self):
command = 'from softwares.maya_wizard.batch_export import batch_export\n'
command += 'batch_export()'
file = utils.temp_file_from_command(command)
mayapy = prefs.software(defaults._mayapy_).path
env = software.get_env(defaults._mayapy_, 0)
env[defaults._asset_var_] = utils.asset_to_string(self.asset)
self.ui_subprocess_manager = ui_subprocess_manager.Main([mayapy, "-u", file], env)
build.launch_normal_as_child(self.ui_subprocess_manager, minimized = 1)
def __init__(self, asset, is_export=1, playblast_version=None):
super(Main, self).__init__()
# Build the ui from ui converted file
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.asset = asset
self.is_export = is_export
self.playblast_version = playblast_version
self.ui.comment_asset_label.setText(utils.asset_to_string(self.asset))
self.ui.comment_dialog_pushButton.setIcon(
QtGui.QIcon(defaults._comment_icon_))
self.connect_functions()
def set_context(self, asset):
self.open_pref_file()
# Check the password concordance
try:
if asset:
self.settings[defaults._asset_context_] = util.asset_to_string(
asset)
else:
self.settings[defaults._asset_context_] = None
except TypeError:
self.settings[defaults._asset_context_] = None
logger.debug('Asset context saved !')
self.write_pref_file()
def batch_asset_creation(asset, in_out):
string_asset = utils.asset_to_string(asset)
command = "import sys\n"
command += "import os\n"
command += "sys.path.append(os.path.abspath(''))\n\n"
command += "from wizard.tools import utility as utils\n"
command += "from wizard.asset import main as asset_core\n\n"
command += f'asset = asset_core.string_to_asset("{string_asset}")\n'
command += f'asset.create({in_out}, batch=1)\n'
command += 'print("status:Done !")'
file = utils.temp_file_from_command(command)
return file
def get_context(self):
self.open_pref_file()
if self.settings[defaults._asset_context_]:
try:
asset = pickle.loads(
self.settings[defaults._asset_context_].encode('utf-8'))
return util.asset_to_string(asset)
except:
try:
asset = self.settings[defaults._asset_context_]
return asset
except:
return None
else:
return None
def event(self, message, id, key, asset=None):
settings = self.open_wall_file()
user = prefs.user
date = util.get_gmtime()
message = message
settings[key] = dict()
settings[key][defaults._creation_user_key_] = user
settings[key][defaults._creation_date_key_] = date
settings[key][defaults._message_key_] = message
settings[key][defaults._wall_id_key_] = id
settings[key][defaults._wall_time_id_key_] = key
if asset:
asset = util.asset_to_string(asset)
settings[key][defaults._asset_key_] = asset
if id != defaults._wall_xp_event_:
self.write_wall_file(settings)
message = util.encode_message(settings[key])
send.send_message(message)
def save():
# Check if a project is already opened:
if substance_painter.project.is_open():
# Check if the project needs to be saved at all:
if substance_painter.project.needs_saving():
save_local()
asset = asset_core.string_to_asset(os.environ[defaults._asset_var_])
asset.version = prefs.asset(asset).software.get_new_version()
shutil.copyfile(get_local_file(), asset.file)
string_asset = utils.asset_to_string(asset)
os.environ[defaults._asset_var_] = string_asset
send_signal.save_request_signal(asset.file, string_asset)
else:
logger.info("There is nothing to save!")
else:
logger.info("No painter project openned!")
def fur(self):
self.command += 'from softwares.maya_wizard.export_fur import export_fur\n'
self.command +='export_fur("{}", "{}", {}, {}, refresh_assets = {}).export_fur()'.format(utils.asset_to_string(self.asset),
self.asset.file.replace('\\', '/'),
self.nspace_list,
self.out_range,
self.refresh_assets)
def run(self):
lock = prefs.asset(self.asset).software.get_lock
if not lock or lock == prefs.user:
logger.info('Launching {}...'.format(self.asset.software))
#prefs.asset(self.asset).software.set_running(0)
os.environ[
defaults.
_current_assets_list_] += ':' + utils.short_asset_to_string(
self.asset)
wizard_path = os.path.abspath('')
python_path = os.path.abspath('ressources\\python27')
python37_path = os.path.abspath('ressources\\python37')
ocio_path = os.path.abspath(
'ressources\\plugins\\color_managment\\aces_1.0.3\\config.ocio'
)
rel_site_script_path = os.path.join(
defaults._softwares_scripts_path_)
abs_site_script_path = os.path.abspath(rel_site_script_path)
env = os.environ.copy()
if self.asset.software != defaults._guerilla_ and self.asset.software != defaults._designer_:
env[defaults._script_software_env_dic_[
self.asset.software]] = abs_site_script_path
env[defaults._script_software_env_dic_[
self.asset.
software]] += os.pathsep + wizard_path + '\\softwares_env'
env[defaults._script_software_env_dic_[
self.asset.
software]] += os.pathsep + python_path + '\\Lib\\site-packages'
if self.asset.software == defaults._houdini_ or self.asset.software == defaults._nuke_:
env[defaults._script_software_env_dic_[
self.asset.software]] = wizard_path + '\\softwares_env'
env[defaults._script_software_env_dic_[
self.asset.
software]] += os.pathsep + python_path + '\\Lib\\site-packages'
'''
if self.asset.software == defaults._houdini_:
env[defaults._script_software_env_dic_[self.asset.software]] += os.pathsep + wizard_path + '\\softwares_env\\softwares\\houdini_wizard'
'''
env_paths = software_prefs.software(
self.asset.software).get_env_paths()
scripts_paths = software_prefs.software(
self.asset.software).get_env()
if scripts_paths:
for path in scripts_paths.splitlines():
env[defaults._script_software_env_dic_[
self.asset.software]] += os.pathsep + path
if env_paths:
for user_env in env_paths.splitlines():
user_env.replace(' ', '')
if '=' in user_env:
key = user_env.split('=')[0]
path = user_env.split('=')[-1]
if key in env.keys():
env[key] += os.pathsep + path
else:
env[key] = path
else:
pass
if self.asset.software == defaults._maya_ or self.asset.software == defaults._maya_yeti_:
if defaults._maya_icon_path_ in env.keys():
env[defaults.
_maya_icon_path_] += os.pathsep + os.path.abspath(
defaults._icon_path_)
else:
env[defaults._maya_icon_path_] = os.path.abspath(
defaults._icon_path_)
if self.asset.software == defaults._nuke_:
env[defaults._script_software_env_dic_[
self.asset.software]] += os.pathsep + abs_site_script_path
env[defaults._script_software_env_dic_[
self.asset.software]] += os.pathsep + os.path.join(
abs_site_script_path, 'nuke_wizard')
env[defaults._script_software_env_dic_[
self.asset.software]] += os.pathsep + os.path.abspath(
defaults._icon_path_)
if self.asset.software == defaults._painter_:
env[defaults._script_software_env_dic_[
self.asset.software]] += os.pathsep + os.path.join(
abs_site_script_path, 'painter_wizard')
if self.asset.software == defaults._designer_:
env[defaults._script_software_env_dic_[
self.asset.
software]] = os.pathsep + python37_path + '\\Lib\\site-packages'
env[defaults._script_software_env_dic_[
self.asset.
software]] += os.pathsep + wizard_path + '\\softwares_env'
env[defaults._script_software_env_dic_[
self.asset.software]] += os.pathsep + os.path.join(
abs_site_script_path, 'designer_wizard')
if self.asset.software == defaults._blender_:
env[defaults._script_software_env_dic_[
self.asset.
software]] = os.pathsep + python37_path + '\\Lib\\site-packages'
env[defaults._script_software_env_dic_[
self.asset.
software]] += os.pathsep + wizard_path + '\\softwares_env'
env[defaults._script_software_env_dic_[
self.asset.software]] += os.pathsep + os.path.join(
abs_site_script_path, 'blender_wizard')
env[defaults._site_var_] = os.environ[defaults._site_var_]
env[defaults._asset_var_] = utils.asset_to_string(self.asset)
self.command = self.command.replace('\\', '/')
logger.info(self.command)
if self.asset.software == defaults._painter_ or self.asset.software == defaults._nuke_:
self.process = subprocess.Popen(self.command,
env=env,
cwd=wizard_path +
'\\softwares_env')
elif self.asset.software == defaults._houdini_:
self.process = subprocess.Popen(
self.command,
env=env,
cwd=wizard_path +
'\\softwares_env\\softwares\\houdini_wizard')
else:
self.process = subprocess.Popen(self.command, env=env)
self.process.wait()
self.earThread.observer.stop()
self.earThread.observer.join()
string_asset = utils.short_asset_to_string(self.asset)
running_assets_list = os.environ[
defaults._current_assets_list_].split(':')
if string_asset in running_assets_list:
running_assets_list.remove(string_asset)
running_assets_list_string = (':').join(running_assets_list)
os.environ[defaults.
_current_assets_list_] = running_assets_list_string
send_signal.refresh_launcher_signal()
logger.info('{} closed'.format(self.software))
else:
message = '{} - '.format(self.asset.category)
message += '{} - '.format(self.asset.name)
message += '{} - '.format(self.asset.stage)
message += '{} - '.format(self.asset.variant)
message += '{} '.format(self.asset.software)
message += 'is locked by {}...'.format(
prefs.asset(self.asset).software.get_lock)
logger.warning(message)
def camera(self):
self.command += '\nfrom softwares.maya_wizard.export_anim import export_anim\n'
self.command += 'export_anim("{}", "{}", {}, frange = {}, refresh_assets = {}).export_cam()'.format(utils.asset_to_string(self.asset),
self.asset.file.replace('\\', '/'),
self.cam_nspace_list,
self.out_range,
self.refresh_assets)
def open_file(self):
widgets_list = self.get_selected_widgets()
for widget in widgets_list:
self.open_signal.emit(utils.asset_to_string(widget.asset))
def open(self):
self.open_signal.emit(utils.asset_to_string(self.asset))
def focus_emit(self):
string_asset = utils.asset_to_string(self.asset)
self.focus.emit(string_asset)
def auto_hair(self):
self.command += 'from softwares.maya_wizard.auto_hair import auto_hair\n'
self.command += 'auto_hair("{}", "{}", {}, frange = {}, set_done = {}, refresh_assets = {}).auto_hair()'.format(utils.asset_to_string(self.asset),
self.asset.file.replace('\\', '/'),
self.nspace_list,
self.out_range,
self.set_done,
self.refresh_assets)
def export_hair(self):
string_asset = utils.asset_to_string(self.cfx_asset)
export_fur(string_asset,
self.cfx_scene, [self.hair_nspace],
self.frange,
set_done=0).export_fur()
