6645 ue5 fixes (#10)

Workarounds for:

- Mac
- Linux
- U5 dev where Shotgun components were renamed to Shotgrid, without backward compatibility in mind.

Author: gplsteph

hooks/tk-multi-publish2/basic/collector.py

@@ -136,7 +136,6 @@ def collect_selected_assets(self, parent_item):
         :param parent_item: Parent Item instance
         """
         unreal_sg = sgtk.platform.current_engine().unreal_sg_engine
-
         # Iterate through the selected assets and get their info and add them as items to be published
         for asset in unreal_sg.selected_assets:
             asset_name = str(asset.asset_name)

plugins/basic/bootstrap.py

@@ -4,10 +4,23 @@
 
 import sys
 import os
+import unreal
 
 # Setup sys.path so that we can import our bootstrapper.
 plugin_root_dir = os.path.abspath(os.path.dirname(__file__))
 sys.path.insert(0, os.path.join(plugin_root_dir, "python"))
 
+# Temp workaround for UE5 dev: for some reasons the core/python path is missing
+# in sys.path but is present in the PYTHONPATH.
+# Make sure sys.path is up to date with what is in the PYTHON PATH
+python_path = os.environ.get("PYTHONPATH") or ""
+for path in python_path.split(os.pathsep):
+    # We can have empty entries for consecutives separators
+    if path and path not in sys.path:
+        unreal.log_warning(
+            "Adding missing %s Python path to sys paths" % path,
+        )
+        sys.path.append(path)
+
 from tk_unreal_basic import plugin_bootstrap
 plugin_bootstrap.bootstrap_plugin(plugin_root_dir)

plugins/basic/python/tk_unreal_basic/plugin_bootstrap.py

@@ -68,8 +68,10 @@ def _on_engine_initialized():
     sgtk_logger.debug("tk-unreal finished initialization.")
 
     import unreal
-
-    unreal.ShotgunEngine.get_instance().on_engine_initialized()
+    if hasattr(unreal, "ShotgridEngine"):
+        unreal.ShotgridEngine.get_instance().on_engine_initialized()
+    else:
+        unreal.ShotgunEngine.get_instance().on_engine_initialized()
 
 
 def _initialize_manager(plugin_root_path):

python/tk_unreal/unreal_sg_engine.py

@@ -8,36 +8,84 @@
 import sys
 import os
 
-unreal.log("Loading Shotgun Engine for Unreal from {}".format(__file__))
+unreal.log("Loading SG Engine for Unreal from {}".format(__file__))
+
+# Shotgun integration components were renamed to Shotgrid from UE5
+if hasattr(unreal, "ShotgridEngine"):
+    UESGEngine = unreal.ShotgridEngine
+
+else:
+    UESGEngine = unreal.ShotgunEngine
 
 
 @unreal.uclass()
-class ShotgunEngineWrapper(unreal.ShotgunEngine):
+class ShotgunEngineWrapper(UESGEngine):
 
     def _post_init(self):
         """
         Equivalent to __init__ but will also be called from C++
         """
         config.wrapper_instance = self
 
-    @unreal.ufunction(override=True)
-    def get_shotgun_menu_items(self):
-        """
-        Returns the list of available menu items to populate the Shotgun menu in Unreal
-        """
-        menu_items = []
-
-        engine = sgtk.platform.current_engine()
-        menu_items = self.create_menu(engine)
-
-        unreal.log("get_shotgun_menu_items returned: {0}".format(menu_items.__str__()))
-
-        return menu_items
+    # Shotgun integration components were renamed to Shotgrid from UE5
+    if hasattr(UESGEngine, "get_shotgrid_menu_items"):
+        @unreal.ufunction(override=True)
+        def get_shotgrid_menu_items(self):
+            """
+            Returns the list of available menu items to populate the SG menu in Unreal.
+            """
+            menu_items = []
+
+            engine = sgtk.platform.current_engine()
+            menu_items = self.create_menu(engine)
+
+            unreal.log("get_shotgrid_menu_items returned: {0}".format(menu_items.__str__()))
+
+            return menu_items
+
+        def get_shotgun_menu_items(self):
+            """
+            Provide backward compatibility.
+            """
+            return self.get_shotgrid_menu_items()
+    else:
+        @unreal.ufunction(override=True)
+        def get_shotgun_menu_items(self):
+            """
+            Returns the list of available menu items to populate the SG menu in Unreal.
+            """
+            menu_items = []
+
+            engine = sgtk.platform.current_engine()
+            menu_items = self.create_menu(engine)
+
+            unreal.log("get_shotgun_menu_items returned: {0}".format(menu_items.__str__()))
+
+            return menu_items
+
+        def get_shotgrid_menu_items(self):
+            """
+            Provide forward compatibility.
+            """
+            return self.get_shotgun_menu_items()
+
+    if hasattr(UESGEngine, "get_shotgrid_work_dir"):
+        def get_shotgun_work_dir(self, *args, **kwargs):
+            """
+            Provide backward compatibility.
+            """
+            return self.get_shotgrid_work_dir(*args, **kwargs)
+    else:
+        def get_shotgrid_work_dir(self, *args, **kwargs):
+            """
+            Provide forward compatibility.
+            """
+            return self.get_shotgun_work_dir(*args, **kwargs)
 
     @unreal.ufunction(override=True)
     def execute_command(self, command_name):
         """
-        Callback to execute the menu item selected in the Shotgun menu in Unreal
+        Callback to execute the menu item selected in the SG menu in Unreal.
         """
         engine = sgtk.platform.current_engine()
 
@@ -58,9 +106,9 @@ def _get_command_override(self, engine, command_name, default_callback):
         :param command_name: The command name to override
         :param default_callback: The callback to use when there's no override
         """
-        # Override the Shotgun Panel command to use the Shotgun Entity context
+        # Override the SG Panel command to use the SG Entity context
         # and also reuse the dialog if one already exists
-        if command_name == "Shotgun Panel...":
+        if command_name in ["Shotgun Panel...", "ShotGrid Panel..."]:
             def show_shotgunpanel_with_context():
                 app = engine.apps["tk-multi-shotgunpanel"]
                 entity_type, entity_id = self._get_context(engine)
@@ -75,7 +123,7 @@ def show_shotgunpanel_with_context():
 
     def _get_context_url(self, engine):
         """
-        Get the Shotgun entity URL from the metadata of the selected asset, if present
+        Get the SG entity URL from the metadata of the selected asset, if present.
         """
         # By default, use the URL of the project
         url = engine.context.shotgun_url
@@ -110,12 +158,12 @@ def _get_context_url(self, engine):
 
     def _get_context(self, engine):
         """
-        Get the Shotgun context (entity type and id) that is associated with the selected menu command
+        Get the SG context (entity type and id) that is associated with the selected menu command.
         """
         entity_type = None
         entity_id = None
 
-        # The context is derived from the Shotgun entity URL
+        # The context is derived from the SG entity URL
         url = self._get_context_url(engine)
         if url:
             # Extract entity type and id from URL, which should follow this pattern:
@@ -173,7 +221,7 @@ def shutdown(self):
 
         engine = sgtk.platform.current_engine()
         if engine is not None:
-            unreal.log("Shutting down ShotgunEngineWrapper")
+            unreal.log("Shutting down %s" % self.__class__.__name__)
 
             # destroy_engine of tk-unreal will take care of closing all dialogs that are still opened
             engine.destroy()
@@ -184,12 +232,12 @@ def shutdown(self):
     Menu generation functionality for Unreal (based on the 3ds max Menu Generation implementation)
 
     Actual menu creation is done in Unreal
-    The following functions simply generate a list of available commands that will populate the Shotgun menu in Unreal
+    The following functions simply generate a list of available commands that will populate the SG menu in Unreal
     """
 
     def create_menu(self, engine):
         """
-        Populate the Shotgun Menu with the available commands
+        Populate the SG Menu with the available commands.
         """
         menu_items = []
 
@@ -257,9 +305,13 @@ def _add_menu_item_from_command(self, menu_items, command):
 
     def _add_menu_item(self, menu_items, type, name="", title="", description=""):
         """
-        Adds a new Unreal ShotgunMenuItem to the menu items
+        Adds a new Unreal SG MenuItem to the menu items.
         """
-        menu_item = unreal.ShotgunMenuItem()
+        # Shotgun integration components were renamed to Shotgrid from UE5
+        if hasattr(unreal, "ShotgridMenuItem"):
+            menu_item = unreal.ShotgridMenuItem()
+        else:
+            menu_item = unreal.ShotgunMenuItem()
         menu_item.title = title
         menu_item.name = name
         menu_item.type = type
@@ -275,15 +327,23 @@ def _start_contextual_menu(self, engine, menu_items):
 
         self._add_menu_item(menu_items, "context_begin", ctx_name, ctx_name)
 
-        engine.register_command("Jump to Shotgun", self._jump_to_sg, {"type": "context_menu", "short_name": "jump_to_sg"})
+        engine.register_command(
+            "Jump to ShotGrid",
+            self._jump_to_sg,
+            {"type": "context_menu", "short_name": "jump_to_sg"}
+        )
 
         # Add the menu item only when there are some file system locations.
         if ctx.filesystem_locations:
-            engine.register_command("Jump to File System", self._jump_to_fs, {"type": "context_menu", "short_name": "jump_to_fs"})
+            engine.register_command(
+                "Jump to File System",
+                self._jump_to_fs,
+                {"type": "context_menu", "short_name": "jump_to_fs"}
+            )
 
     def _jump_to_sg(self):
         """
-        Callback to Jump to Shotgun from context
+        Callback to Jump to SG from context.
         """
         from sgtk.platform.qt5 import QtGui, QtCore
         url = self._get_context_url(sgtk.platform.current_engine())