[plugin] Draft: Develop Blender plugin

cuesubmit/plugins/OpenCue/Setup.py

@@ -0,0 +1,96 @@
+#  Copyright Contributors to the OpenCue Project
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import sys
+import subprocess
+import os
+import platform
+import bpy
+
+
+def isWindows():
+    return os.name == 'nt'
+
+
+def isMacOS():
+    return os.name == 'posix' and platform.system() == "Darwin"
+
+
+def isLinux():
+    return os.name == 'posix' and platform.system() == "Linux"
+
+
+def python_exec():
+    if isWindows():
+        return os.path.join(sys.prefix, 'bin', 'python.exe')
+    elif isMacOS():
+        try:
+            # 2.92 and older
+            path = bpy.app.binary_path_python
+        except AttributeError:
+            # 2.93 and later
+            path = sys.executable
+        return os.path.abspath(path)
+    elif isLinux():
+        return os.path.join(sys.prefix, 'bin', 'python3.10')  # Works on Blender 3.3.1 LTS
+    else:
+        print("sorry, still not implemented for ", os.name, " - ", platform.system)
+        return os.path.join(sys.prefix, 'sys.prefix/bin', 'python')
+
+
+def installModule():
+    # Get path of requirements file
+    script_file = os.path.realpath(__file__)
+    directory = os.path.dirname(script_file)
+    file_name = "requirements.txt"
+    requirements = os.path.join(directory, file_name)
+
+    # identify for platform
+    python_exe = python_exec()
+
+    blender_dependencies_directory = "lib/python3.10/site-packages"
+    blender_dependencies_path = os.path.join(sys.prefix, blender_dependencies_directory)
+
+    # upgrade pip
+    subprocess.call([python_exe, "-m", "ensurepip"])
+    subprocess.call([python_exe, "-m", "pip", "install", "--upgrade", "pip"])
+    # install required external packages
+    subprocess.call([python_exe, "-m", "pip", "install", "-r", requirements, "-t", blender_dependencies_path])
+
+    # install OpenCue dependencies
+    opencue_home = os.environ['OPENCUE_HOME']
+    pyoutline_directory = "pyoutline/outline"
+    filesequence_directory = "pycue/FileSequence"
+    opencue_directory = "pycue/opencue"
+
+    pyoutline_path = os.path.join(opencue_home, pyoutline_directory)
+    filesequence_path = os.path.join(opencue_home, filesequence_directory)
+    opencue_path = os.path.join(opencue_home, opencue_directory)
+
+    subprocess.call(["cp", "-r", pyoutline_path, blender_dependencies_path])
+    subprocess.call(["cp", "-r", filesequence_path, blender_dependencies_path])
+    subprocess.call(["cp", "-r", opencue_path, blender_dependencies_path])
+
+def removeModule():
+    # remove installed opencue dependencies
+    blender_dependencies_directory = "lib/python3.10/site-packages"
+    pyoutline_directory = "outline"
+    opencue_imported_directory = "opencue"
+    pyoutline_directory_path = os.path.join(sys.prefix, blender_dependencies_directory, pyoutline_directory)
+    opencue_directory_path = os.path.join(sys.prefix, blender_dependencies_directory, opencue_imported_directory)
+
+    subprocess.call(["rm", "-rf", pyoutline_directory_path])
+    subprocess.call(["rm", "-rf", opencue_directory_path])
+
+

cuesubmit/plugins/OpenCue/Submission.py

@@ -0,0 +1,75 @@
+
+import outline
+import outline.cuerun
+import outline.modules.shell
+
+import bpy
+
+def buildBlenderCmd(layerData):
+    blenderFile = layerData.get('cmd').get('blenderFile')
+    outputPath = layerData.get('cmd').get('outputPath')
+    outputFormat = layerData.get('cmd').get('outputFormat')
+
+    # Hardware use for rendering
+    addon_prefs = bpy.context.preferences.addons['OpenCue'].preferences
+    use_gpu = addon_prefs.use_gpu
+    if use_gpu:
+        renderHW = "CUDA"
+    else:
+        renderHW = "CPU"
+
+    if not blenderFile:
+        raise ValueError('No Blender file provided. Cannot submit job.')
+
+    renderCommand = '{renderCmd} -b -noaudio {blenderFile} -E CYCLES'.format(
+        renderCmd="blender", blenderFile=blenderFile)
+    if outputPath:
+        renderCommand += ' -o {}'.format(outputPath)
+    if outputFormat:
+        renderCommand += ' -F {}'.format(outputFormat)
+    # The render frame must come after the scene and output
+    # renderCommand += ' -f {frameToken}'.format(frameToken="#IFRAME#")
+    renderCommand += ' -f 1 -- --cycles-device {renderHW}'.format(renderHW=renderHW)
+    return renderCommand
+
+def buildLayer(layerData, command, lastLayer=None):
+    """Creates a PyOutline Layer for the given layerData.
+
+    @type layerData: ui.Layer.LayerData
+    @param layerData: layer data from the ui
+    @type command: str
+    @param command: command to run
+    @type lastLayer: outline.layer.Layer
+    @param lastLayer: layer that this new layer should be dependent on if dependType is set.
+    """
+    threadable = float(layerData.get('cores')) >= 2
+    layer = outline.modules.shell.Shell(
+        layerData.get('name'), command=command.split(), chunk=layerData.get('chunk'),
+        threads=float(layerData.get('cores')), range=str(layerData.get('layerRange')), threadable=threadable)
+    if layerData.get('services'):
+        layer.set_service(layerData.services[0])
+    if layerData.get('limits'):
+        layer.set_limits(layerData.limits)
+    if layerData.get('dependType') and lastLayer:
+        if layerData.dependType == 'Layer':
+            layer.depend_all(lastLayer)
+        else:
+            layer.depend_on(lastLayer)
+    return layer
+
+def buildBlenderLayer(layerData, lastLayer):
+    """Builds a PyOutline layer running a Blender command."""
+    blenderCmd = buildBlenderCmd(layerData)
+    return buildLayer(layerData, blenderCmd, lastLayer)
+
+def submit(jobData):
+    """Submits the job using the PyOutline API."""
+    ol = outline.Outline(
+        jobData['name'], shot=jobData['shot'], show=jobData['show'], user=jobData['username'])
+    lastLayer = None
+    layerData = jobData['layers']
+    layer = buildBlenderLayer(layerData, lastLayer)
+    ol.add_layer(layer)
+    lastLayer = layer
+
+    return outline.cuerun.launch(ol, use_pycuerun=False)

cuesubmit/plugins/OpenCue/__init__.py

@@ -0,0 +1,155 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import absolute_import
+
+bl_info = {
+    "name": "OpenCue",
+    "author": "Nuwan Jayawardene",
+    "version": (0, 0, 0, 1),
+    "blender": (3, 3, 1),
+    "description": "OpenCue client for Blender.",
+    "location": "Output Properties > OpenCue",
+    "category": "System",
+}
+
+import bpy
+
+from . import Setup
+
+class SubmitJob(bpy.types.Operator):
+    bl_idname = "object.submit_job"
+    bl_label = "My Operator"
+
+    def execute(self, context):
+        layerData = {
+            'name': context.scene.layer_name,
+            'layerType': 'Blender',
+            'cmd': {
+                'blenderFile': bpy.data.filepath,
+                'outputPath': '',
+                'outputFormat': 'PNG'
+            },
+            'layerRange': '1',
+            'chunk': '1',
+            'cores': '0',
+            'env': {},
+            'services': [],
+            'limits': [],
+            'dependType': '',
+            'dependsOne': None
+        }
+
+        jobData = {
+            'name': context.scene.job_name,
+            'username': context.scene.usr_name,
+            'show': "testing",
+            'shot': context.scene.shot_name,
+            'layers': layerData
+        }
+
+        from . import Submission
+        Submission.submit(jobData)
+
+
+class OpenCuePanel(bpy.types.Panel):
+    """A custom panel in the 3D View Properties region"""
+    bl_label = "OpenCue"
+    bl_idname = "SCENE_PT_layout"  # VIEW_3D_opencue_panel
+    bl_space_type = 'PROPERTIES'  # VIEW_3D
+    bl_region_type = 'WINDOW'  # UI
+    bl_category = "render"  # Properties
+
+    def draw(self, context):
+        layout = self.layout
+
+        col = layout.column()
+        col.prop(context.scene, "job_name")
+
+        col = layout.column()
+        col.prop(context.scene, "usr_name")
+
+        col = layout.column()
+        col.prop(context.scene, "layer_name")
+
+        col = layout.column()
+        col.prop(context.scene, "shot_name")
+
+        col = layout.column()
+        col.operator("object.submit_job", text="Submit")
+
+
+class OpenCueAddonPreferences(bpy.types.AddonPreferences):
+    bl_idname = __name__
+
+    is_dependency_install: bpy.props.BoolProperty(
+        name="Dependency Install",
+        default=False,
+        description="Flag to indicate if dependencies have been installed during first install",
+    )
+
+    use_gpu: bpy.props.BoolProperty(
+        name="Use GPU for rendering",
+        default=False,
+        description="Enable to utilize GPU rendering for jobs",
+    )
+
+    output_path: bpy.props.StringProperty(
+        name="OpenCue output path",
+        default="",
+    )
+    def draw(self, context):
+        layout = self.layout
+        layout.prop(self, "is_dependency_install")
+        layout.prop(self, "use_gpu")
+        layout.prop(self, "output_path")
+
+def register():
+    bpy.utils.register_class(OpenCueAddonPreferences)
+
+    bpy.types.Scene.job_name = bpy.props.StringProperty(
+        name="Job name",
+        description="Enter some text",
+        default=""
+    )
+
+    bpy.types.Scene.usr_name = bpy.props.StringProperty(
+        name="User name",
+        description="Enter some text",
+        default=""
+    )
+
+    bpy.types.Scene.layer_name = bpy.props.StringProperty(
+        name="Layer name",
+        description="Enter some text",
+        default=""
+    )
+
+    bpy.types.Scene.shot_name = bpy.props.StringProperty(
+        name="Shot name",
+        description="Enter some text",
+        default=""
+    )
+
+    bpy.utils.register_class(OpenCuePanel)
+
+    addon_pref = bpy.context.preferences.addons[__name__].preferences
+    if not addon_pref.is_dependency_install:
+        Setup.installModule()
+        bpy.context.preferences.addons[__name__].preferences.is_dependency_install = True
+
+        bpy.utils.register_class(SubmitJob)
+
+
+def unregister():
+    bpy.utils.unregister_class(OpenCuePanel)
+    bpy.utils.unregister_class(SubmitJob)
+    bpy.utils.unregister_class(OpenCueAddonPreferences)
+    del bpy.types.Scene.job_name
+    del bpy.types.Scene.usr_name
+    del bpy.types.Scene.layer_name
+
+    Setup.removeModule()
+
+
+if __name__ == "__main__":
+    register()

cuesubmit/plugins/OpenCue/requirements.txt

@@ -0,0 +1,6 @@
+future==0.18.3
+PyYAML==5.1
+packaging==20.9
+grpcio==1.47.0
+grpcio-tools==1.47.0
+google