[plugin] Draft: Develop Blender plugin

.github/workflows/packaging-pipeline.yml

@@ -153,6 +153,15 @@ jobs:
           export OPENCUE_RQD_PACKAGE_PATH="${{ needs.build_opencue_packages.outputs.opencue_rqd_path }}"
           ci/run_integration_test.sh
 
+      - name: Build blender addon
+        run: ci/build_blender_addon.sh
+
+      - name: Upload blender addon artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: OpenCue-Blender
+          path: ${GITHUB_WORKSPACE}/artifacts/OpenCue-Blender.zip
+
       - name: Archive log files
         uses: actions/upload-artifact@v4
         if: ${{ always() }}

ci/build_blender_addon.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+#  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.
+
+# OpenCue integration test script
+#
+# Stands up a clean environment using Docker compose and verifies all
+# components are functioning as expected.
+#
+# Run with:
+#   ./ci/build_blender_addon.sh
+
+set -e
+
+PYOUTLINE_PATH="pyoutline/outline"
+FILESEQUENCE_PATH="pycue/FileSequence"
+OPENCUE_PATH="pycue/opencue"
+
+ADDON_PATH="cuesubmit/plugins/blender/OpenCue-Blender/"
+
+log() {
+    echo "$(date "+%Y-%m-%d %H:%M:%S") $1 $2"
+}
+
+copy_dependencies() {
+  DEPENDENCIES_PATH="${ADDON_PATH}/dependencies"
+  mkdir -p "${DEPENDENCIES_PATH}"
+  cp -r "${PYOUTLINE_PATH}" "${DEPENDENCIES_PATH}"
+  cp -r "${FILESEQUENCE_PATH}" "${DEPENDENCIES_PATH}"
+  cp -r "${OPENCUE_PATH}" "${DEPENDENCIES_PATH}"
+}
+
+main() {
+  log INFO "Copying dependencies into ${ADDON_PATH}"
+  copy_dependencies
+  # Check if script is running within GitHub Actions pipeline
+  if [ "$GITHUB_ACTIONS" == "true" ]; then
+    log INFO "Generating zip in ${GITHUB_WORKSPACE}/artifacts/"
+    mkdir -p "${GITHUB_WORKSPACE}/artifacts/"
+    cd cuesubmit/plugins/blender
+    zip -r "${GITHUB_WORKSPACE}/artifacts/OpenCue-Blender.zip" OpenCue-Blender/
+  else
+    log INFO "Generating zip in cuesubmit/plugins/blender/"
+    cd cuesubmit/plugins/blender
+    zip -r "OpenCue-Blender.zip" OpenCue-Blender/
+  fi
+}
+
+main

ci/run_integration_test.sh

@@ -188,8 +188,40 @@ run_job() {
     log INFO "Job succeeded (PASS)"
 }
 
+run_blender_job() {
+    cp samples/pyoutline/sample.blend $RQD_ROOT
+    samples/pyoutline/blender_job.py
+    job_name="testing-shot02-${USER}_blender_job"
+    samples/pycue/wait_for_job.py "${job_name}" --timeout 300
+    log INFO "Blender job succeeded (PASS)"
+}
+
+add_RQD_tag() {
+    container_id=$(docker ps --filter "name=blender" --format "{{.ID}}")
+    got_hosts=$(python -c 'import opencue; print([host.name() for host in opencue.api.getHosts()])')
+    host_exists=false
+    for host in $(echo "${got_hosts}" | tr -d '[],' | tr -d "'" | tr ' ' '\n'); do
+      if [[ "$host" == "$container_id" ]]; then
+          host_exists=true
+          break
+      fi
+    done
+
+    if [[ "$host_exists" == true ]]; then
+      log INFO "Adding tag to Blender RQD"
+      python -c "import opencue; import opencue.wrappers.host; \
+                  host=opencue.api.findHost('${container_id}'); \
+                  tags = ['blender']; \
+                  host.addTags(tags)"
+    else
+        log ERROR "Blender RQD not detected by Cuebot. Unable to add tag"
+        exit 1
+    fi
+}
+
 cleanup() {
     docker compose rm --stop --force >>"${DOCKER_COMPOSE_LOG}" 2>&1
+    docker rm -f blender
     rm -rf "${RQD_ROOT}" || true
     rm -rf "${DB_DATA_DIR}" || true
     rm -rf "${VENV}" || true
@@ -265,6 +297,25 @@ main() {
 
     run_job
 
+    log INFO "Starting RQD Blender..."
+    docker run -td --name blender \
+    --env CUEBOT_HOSTNAME=cuebot \
+    --volume "/tmp/rqd/shots:/tmp/rqd/shots" \
+    --volume "/tmp/rqd/logs:/tmp/rqd/logs" \
+    -p 8441:8441 \
+    --network opencue_default \
+    opencue/blender
+
+    docker exec blender sh -c 'echo "RQD_USE_IP_AS_HOSTNAME=False" >> /etc/opencue/rqd.conf'
+    log INFO "Restarting RQD Blender..."
+    docker restart blender
+    sleep 3
+
+    add_RQD_tag
+
+    log INFO "Testing Blender job..."
+    run_blender_job
+
     cleanup
 
     log INFO "Success"

cuesubmit/plugins/blender/OpenCue-Blender/Setup.py

@@ -0,0 +1,117 @@
+#  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 shutil
+import sys
+import subprocess
+import os
+import platform
+import bpy
+
+blender_dependencies_directory = "lib/python3.10/site-packages"
+blender_dependencies_path = os.path.join(sys.prefix, blender_dependencies_directory)
+opencue_blender_path = os.path.dirname(__file__)
+
+pyoutline_path = os.path.join(opencue_blender_path, "dependencies", "outline")
+filesequence_path = os.path.join(opencue_blender_path, "dependencies", "FileSequence")
+opencue_path = os.path.join(opencue_blender_path, "dependencies", "opencue")
+
+pyoutline_directory = "outline"
+opencue_imported_directory = "opencue"
+filesequence_imported_directory = "FileSequence"
+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)
+filesequence_directory_path = os.path.join(sys.prefix, blender_dependencies_directory, filesequence_imported_directory)
+
+
+def isWindows():
+    """Checks if host OS is Windows"""
+    return os.name == 'nt'
+
+
+def isMacOS():
+    """Checks if host OS is macOS"""
+    return os.name == 'posix' and platform.system() == "Darwin"
+
+
+def isLinux():
+    """Checks if host OS is Linux"""
+    return os.name == 'posix' and platform.system() == "Linux"
+
+
+def python_exec():
+    """Sets Blender local python based on host OS"""
+    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():
+    """Installs all addon dependencies during registration"""
+    # Install OpenCue dependencies
+    installOpencueModules()
+
+    # installs External modules from requirements.txt file
+    installExternalModules()
+
+    print("\n----- OpenCue-Blender Installed Successfully -----")
+
+
+def installExternalModules():
+    """Installs externals dependencies onto Blender python environment with pip"""
+    # 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()
+
+    # upgrade pip
+    print("\n----- Installing External Dependencies -----")
+    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])
+    print("\n----- External Dependencies Installed Successfully -----")
+
+
+def installOpencueModules():
+    """Installs OpenCue dependencies onto Blender python environment"""
+    print("----- Installing OpenCue Dependencies -----")
+    shutil.copytree(pyoutline_path, pyoutline_directory_path)
+    shutil.copytree(opencue_path, opencue_directory_path)
+    shutil.copytree(filesequence_path, filesequence_directory_path)
+    print("\n----- OpenCue Dependencies Installed Successfully -----")
+
+
+def removeOpencueModules():
+    """Removes OpenCue dependencies from Blender python environment"""
+    # remove installed opencue dependencies
+    shutil.rmtree(pyoutline_directory_path)
+    shutil.rmtree(opencue_directory_path)
+    shutil.rmtree(filesequence_directory_path)

cuesubmit/plugins/blender/OpenCue-Blender/Submission.py

@@ -0,0 +1,103 @@
+#  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 outline
+import outline.cuerun
+import outline.modules.shell
+
+import bpy
+import re
+
+def buildBlenderCmd(layerData):
+    """Builds the Blender command from layerdata
+
+    @param layerData: layer data from the ui
+    """
+    blenderFile = layerData.get('cmd').get('blenderFile')
+    outputPath = layerData.get('cmd').get('outputPath')
+    outputFormat = layerData.get('cmd').get('outputFormat')
+    frameRange = layerData.get('layerRange')
+
+    # Hardware use for rendering
+    addon_prefs = bpy.context.preferences.addons['OpenCue-Blender'].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}'.format(
+        renderCmd="blender", blenderFile=blenderFile)
+    if outputPath:
+        renderCommand += ' -o {}'.format(outputPath)
+    if outputFormat:
+        renderCommand += ' -F {}'.format(outputFormat)
+    # Option to render still frame or animation must come after the scene and output
+    if re.match(r"^\d+-\d+$", frameRange):
+        renderCommand += ' -s {frameStart} -e {frameEnd} -a'.format(
+            frameStart="#FRAME_START#",
+            frameEnd="#FRAME_END#")
+    else:
+        renderCommand += ' -f {frameToken}'.format(frameToken="#IFRAME#")
+    renderCommand += ' -E CYCLES -- --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)