Frame13/ayon-core
1
0
Fork 1
mirror of https://github.com/ynput/ayon-core.git synced 2026-01-02 00:44:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

OP-2766 - implemented new image Creator

Browse source 
Working implementation of New Publisher (not full backward compatibility yet).
This commit is contained in:
Petr Kalis 2022-03-16 16:18:07 +01:00
parent bff1b77c06
commit c46b41804d
7 changed files with 148 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

8
openpype/hosts/photoshop/api/__init__.py
View file

@ -12,7 +12,10 @@ from .pipeline import (
remove_instance,
install,
uninstall,
containerise
containerise,
get_context_data,
update_context_data,
get_context_title
)
from .plugin import (
PhotoshopLoader,
@ -43,6 +46,9 @@ __all__ = [
"install",
"uninstall",
"containerise",
"get_context_data",
"update_context_data",
"get_context_title",
# Plugin
"PhotoshopLoader",

156
openpype/hosts/photoshop/plugins/create/create_image.py
View file

@ -1,46 +1,50 @@
from Qt import QtWidgets
from openpype.pipeline import create
from openpype.hosts.photoshop import api as photoshop
from avalon import api as avalon_api
from openpype.hosts.photoshop import api
from openpype.pipeline import (
Creator,
CreatedInstance,
lib,
CreatorError
)
class CreateImage(create.LegacyCreator):
"""Image folder for publish."""
name = "imageDefault"
class ImageCreator(Creator):
"""Creates image instance for publishing."""
identifier = "image"
label = "Image"
family = "image"
defaults = ["Main"]
description = "Image creator"
def process(self):
def collect_instances(self):
import json
self.log.info("ImageCreator: api.list_instances():: {}".format(
json.dumps(api.list_instances(), indent=4)))
for instance_data in api.list_instances():
# legacy instances have family=='image'
creator_id = (instance_data.get("creator_identifier") or
instance_data.get("family"))
self.log.info("ImageCreator: instance_data:: {}".format(json.dumps(instance_data, indent=4)))
if creator_id == self.identifier:
instance_data = self._handle_legacy(instance_data)
layer = api.stub().get_layer(instance_data["members"][0])
instance_data["layer"] = layer
instance = CreatedInstance.from_existing(
instance_data, self
)
self._add_instance_to_context(instance)
def create(self, subset_name, data, pre_create_data):
groups = []
layers = []
create_group = False
stub = photoshop.stub()
if (self.options or {}).get("useSelection"):
multiple_instances = False
selection = stub.get_selected_layers()
self.log.info("selection {}".format(selection))
stub = api.stub() # only after PS is up
multiple_instances = pre_create_data.get("create_multiple")
selection = stub.get_selected_layers()
if pre_create_data.get("use_selection"):
if len(selection) > 1:
# Ask user whether to create one image or image per selected
# item.
msg_box = QtWidgets.QMessageBox()
msg_box.setIcon(QtWidgets.QMessageBox.Warning)
msg_box.setText(
"Multiple layers selected."
"\nDo you want to make one image per layer?"
)
msg_box.setStandardButtons(
QtWidgets.QMessageBox.Yes |
QtWidgets.QMessageBox.No |
QtWidgets.QMessageBox.Cancel
)
ret = msg_box.exec_()
if ret == QtWidgets.QMessageBox.Yes:
multiple_instances = True
elif ret == QtWidgets.QMessageBox.Cancel:
return
if multiple_instances:
for item in selection:
if item.group:
@ -48,25 +52,25 @@ class CreateImage(create.LegacyCreator):
else:
layers.append(item)
else:
group = stub.group_selected_layers(self.name)
group = stub.group_selected_layers(subset_name)
groups.append(group)
elif len(selection) == 1:
# One selected item. Use group if its a LayerSet (group), else
# create a new group.
if selection[0].group:
groups.append(selection[0])
selected_item = selection[0]
if selected_item.group:
groups.append(selected_item)
else:
layers.append(selection[0])
layers.append(selected_item)
elif len(selection) == 0:
# No selection creates an empty group.
create_group = True
else:
group = stub.create_group(self.name)
group = stub.create_group(subset_name)
groups.append(group)
if create_group:
group = stub.create_group(self.name)
group = stub.create_group(subset_name)
groups.append(group)
for layer in layers:
@ -74,26 +78,78 @@ class CreateImage(create.LegacyCreator):
group = stub.group_selected_layers(layer.name)
groups.append(group)
creator_subset_name = self.data["subset"]
for group in groups:
long_names = []
group.name = group.name.replace(stub.PUBLISH_ICON, ''). \
replace(stub.LOADED_ICON, '')
group.name = self._clean_highlights(stub, group.name)
subset_name = creator_subset_name
if len(groups) > 1:
subset_name += group.name.title().replace(" ", "")
if group.long_name:
for directory in group.long_name[::-1]:
name = directory.replace(stub.PUBLISH_ICON, '').\
replace(stub.LOADED_ICON, '')
name = self._clean_highlights(stub, directory)
long_names.append(name)
self.data.update({"subset": subset_name})
self.data.update({"uuid": str(group.id)})
self.data.update({"long_name": "_".join(long_names)})
stub.imprint(group, self.data)
data.update({"subset": subset_name})
data.update({"layer": group})
data.update({"members": [str(group.id)]})
data.update({"long_name": "_".join(long_names)})
new_instance = CreatedInstance(self.family, subset_name, data,
self)
stub.imprint(new_instance.get("instance_id"),
new_instance.data_to_store())
self._add_instance_to_context(new_instance)
# reusing existing group, need to rename afterwards
if not create_group:
stub.rename_layer(group.id, stub.PUBLISH_ICON + group.name)
def update_instances(self, update_list):
self.log.info("update_list:: {}".format(update_list))
created_inst, changes = update_list[0]
api.stub().imprint(created_inst.get("instance_id"),
created_inst.data_to_store())
def remove_instances(self, instances):
for instance in instances:
api.remove_instance(instance)
self._remove_instance_from_context(instance)
def get_default_variants(self):
return [
"Main"
]
def get_pre_create_attr_defs(self):
output = [
lib.BoolDef("use_selection", default=True, label="Use selection"),
lib.BoolDef("create_multiple",
default=True,
label="Create separate instance for each selected")
]
return output
def get_detail_description(self):
return """Creator for Image instances"""
def _handle_legacy(self, instance_data):
"""Converts old instances to new format."""
if not instance_data.get("members"):
instance_data["members"] = [instance_data.get("uuid")]
if instance_data.get("uuid"):
# uuid not needed, replaced with unique instance_id
api.stub().remove_instance(instance_data.get("uuid"))
instance_data.pop("uuid")
if not instance_data.get("task"):
instance_data["task"] = avalon_api.Session.get("AVALON_TASK")
return instance_data
def _clean_highlights(self, stub, item):
return item.replace(stub.PUBLISH_ICON, '').replace(stub.LOADED_ICON,
'')

2
openpype/hosts/photoshop/plugins/create/create_legacy_image.py
View file

@ -91,7 +91,7 @@ class CreateImage(create.LegacyCreator):
long_names.append(name)
self.data.update({"subset": subset_name})
self.data.update({"uuid": str(group.id)})
self.data.update({"members": [str(group.id)]})
self.data.update({"long_name": "_".join(long_names)})
stub.imprint(group, self.data)
# reusing existing group, need to rename afterwards

2
openpype/hosts/photoshop/plugins/create/workfile_creator.py
View file

@ -15,6 +15,7 @@ class PSWorkfileCreator(AutoCreator):
return []
def collect_instances(self):
print("coll::{}".format(api.list_instances()))
for instance_data in api.list_instances():
creator_id = instance_data.get("creator_identifier")
if creator_id == self.identifier:
@ -29,6 +30,7 @@ class PSWorkfileCreator(AutoCreator):
pass
def create(self, options=None):
print("create")
existing_instance = None
for instance in self.create_context.instances:
if instance.family == self.family:

4
openpype/hosts/photoshop/plugins/publish/collect_instances.py
View file

@ -21,6 +21,10 @@ class CollectInstances(pyblish.api.ContextPlugin):
}
def process(self, context):
if context.data.get("newPublishing"):
self.log.debug("Not applicable for New Publisher, skip")
return
stub = photoshop.stub()
layers = stub.get_layers()
layers_meta = stub.get_layers_metadata()

30
openpype/hosts/photoshop/plugins/publish/collect_workfile.py
View file

@ -10,6 +10,13 @@ class CollectWorkfile(pyblish.api.ContextPlugin):
hosts = ["photoshop"]
def process(self, context):
existing_instance = None
for instance in context:
if instance.data["family"] == "workfile":
self.log.debug("Workfile instance found, won't create new")
existing_instance = instance
break
family = "workfile"
task = os.getenv("AVALON_TASK", None)
subset = family + task.capitalize()
@ -19,16 +26,19 @@ class CollectWorkfile(pyblish.api.ContextPlugin):
base_name = os.path.basename(file_path)
# Create instance
instance = context.create_instance(subset)
instance.data.update({
"subset": subset,
"label": base_name,
"name": base_name,
"family": family,
"families": [],
"representations": [],
"asset": os.environ["AVALON_ASSET"]
})
if existing_instance is None:
instance = context.create_instance(subset)
instance.data.update({
"subset": subset,
"label": base_name,
"name": base_name,
"family": family,
"families": [],
"representations": [],
"asset": os.environ["AVALON_ASSET"]
})
else:
instance = existing_instance
# creating representation
_, ext = os.path.splitext(file_path)

9
openpype/hosts/photoshop/plugins/publish/extract_image.py
View file

@ -16,7 +16,8 @@ class ExtractImage(openpype.api.Extractor):
formats = ["png", "jpg"]
def process(self, instance):
print("PPPPPP")
self.log.info("fdfdsfdfs")
staging_dir = self.staging_dir(instance)
self.log.info("Outputting image to {}".format(staging_dir))
@ -26,7 +27,13 @@ class ExtractImage(openpype.api.Extractor):
with photoshop.maintained_selection():
self.log.info("Extracting %s" % str(list(instance)))
with photoshop.maintained_visibility():
self.log.info("instance.data:: {}".format(instance.data))
print("instance.data::: {}".format(instance.data))
layer = instance.data.get("layer")
self.log.info("layer:: {}".format(layer))
print("layer::: {}".format(layer))
if not layer:
return
ids = set([layer.id])
add_ids = instance.data.pop("ids", None)
if add_ids: