Enhancement: Render / Turntable

assets/turntable/README.md

@@ -0,0 +1,85 @@
+#### USD Turntable Presets And You
+
+---
+#### Turning tables
+
+`usd-qtpy` supports the rendering of assets with a turntable preset.
+This turntable preset is a USD file, that gets referenced along with a temporary
+export of the scene itself.
+
+By using a hierarchical structure that conforms to the standard, you too 
+can make a preset that turns your tables the exact way you wish your tables
+to be turned.
+
+#### Getting started
+
+The turntable preset system requires the hierarchy to be laid out like so:
+
+```
+/
+│
+└─ turntable (Xform, default prim)
+     │
+     ├─ scene (Xform)
+     │    │
+     |    ├─ lights (Xform) (Optional)
+     │    │    └─ [all lights in scene]
+     │    │
+     │    ├─ camera (Camera pointing at your target)
+     │    │
+     │    └─ [some scene geometry] (Optional)
+     │
+     ├─ parent (Xform, usually holds rotation animation)
+     │
+     └─ bounds (Xform) (Optional)
+          │
+          └─ [some invisible geometry that fits the bounds of your camera]
+
+```
+
+You can look at an example of a complete compliant hierarchy,
+in `turntable_preset.usda`.
+It isn't required to have a usda file, usd and usdc are supported as well.
+
+##### Things that matter:
+- `turntable` needs to be the default primitive
+- Some Usd Camera needs to be present in the hierarchy
+- `parent` must exist
+- At least 1 `camera` exists somewhere (the first found camera will be used)
+
+##### Things that don't matter:
+- `bounds` doesn't have to exist
+- `scene/lights` doesn't have to exist
+- `camera` can be named anything and can exist everywhere in the hierarchy.
+
+#### Functionality in the turntable system:
+##### Bounds:
+There are times where you are unsure whether assets will fit in the camera view.
+This worry can be entirely mitigated by including the bounds Xform, with some
+geometry in it that fills the camera view.
+
+If `bounds` is present, the turntable will automagically fit the geometry
+uniformly so that it fits the bounds of the geometry contained in this Xform.
+
+##### Scene lights:
+Scene lights can be included with any name in any order. These will be turned
+off for GL renders, because GL renders are lit by default. The introduction
+of lights would make the renders overexposed.
+
+Should you still want to have lights regardless of the renderer being used,
+just include them them in `scene`.
+
+##### Parent:
+This is where the subject of the turntable will end up,
+and it's usually an Xform that holds rotation frames.
+
+The subject is placed at the centroid and lower bound in the middle of the scene
+automatically, meaning that you can place `parent` pretty much wherever you want
+in the scene, the subject will inherit its transforms.
+
+##### Limits (for now):
+- USD attributes `endTimeCode` and `startTimeCode` are not able to be read, 
+I might attempt to parse the actual description of the USD scene in the future, 
+but for now, manual entry of  start and end timecodes is needed.
+
+##### Happy turntabling!

pyproject.toml

@@ -11,6 +11,7 @@ name = "usd-qtpy"
 authors = [
     {name = "BigRoy"},
     {name = "Hannes"},
+    {name = "Sasbom"},
 ]
 description = "Python Qt components for building custom USD tools."
 readme = "README.md"

usd_qtpy/editor.py

@@ -29,6 +29,8 @@ def __init__(self, stage, parent=None):
             title = f"{title}: {name}"
         self.setWindowTitle(title)
 
+        self._stage = stage
+
         self.setWindowFlags(
             self.windowFlags() |
             QtCore.Qt.Dialog
@@ -49,8 +51,10 @@ def __init__(self, stage, parent=None):
         splitter.addWidget(hierarchy_widget)
 
         viewer_widget = None
+        self._stageview = None
         if HAS_VIEWER:
             viewer_widget = viewer.Widget(stage=stage)
+            self._stageview = viewer_widget.view
             splitter.addWidget(viewer_widget)
 
         prim_spec_editor_widget = prim_spec_editor.SpecEditorWindow(stage=stage)
@@ -75,6 +79,7 @@ def build_menubar(self):
 
         menubar = QtWidgets.QMenuBar()
 
+        # Panels menu
         panels_menu = menubar.addMenu("Panels")
         for label, widget in self._panels.items():
             action = panels_menu.addAction(label)
@@ -94,5 +99,65 @@ def update_panel_checkstate():
 
         panels_menu.aboutToShow.connect(update_panel_checkstate)
 
+        if HAS_VIEWER:
+            self._build_render_menu(menubar)
+
         layout = self.layout()
         layout.setMenuBar(menubar)
+
+    def _build_render_menu(self, menubar):
+
+        # Import here because we only want to import this dependency
+        # if the viewer libraries exist
+        from . import render_util
+
+        # Render menu
+        render_menu = menubar.addMenu("Render")
+        labels = (
+            "Snapshot View",
+            "Snapshot Framing Camera",
+            "Playblast Stage",
+            "Turntable Stage"
+        )
+        actions = {label: render_menu.addAction(label) for label in labels}
+
+        def render_snap():
+            """Render still frame from current view"""
+            # TODO: Allow picking resolution
+            filepath = render_util.prompt_output_path("Save frame")
+            if not filepath:
+                return
+            render_util.dialog.save_image_from_stageview(self._stageview,
+                                                         filepath)
+
+        def render_snap_framed():
+            """Render still frame from a 'framed camera'"""
+            filepath = render_util.prompt_output_path("Save frame with framing camera")
+            if not filepath:
+                return
+            stage = self._stage
+            camera = render_util.create_framing_camera_in_stage(stage, fit=1.1)
+            render_util.render_playblast(stage, 
+                                         filepath,
+                                         "1", 
+                                         1920, 
+                                         renderer="GL", 
+                                         camera=camera)
+            stage.RemovePrim(camera.GetPath())
+
+        def playblast_stage_dialog():
+            dialog = render_util.PlayblastDialog(self,
+                                                 self._stage,
+                                                 self._stageview)
+            dialog.show()
+
+        def turntable_stage_dialog():
+            dialog = render_util.TurntableDialog(self,
+                                                 self._stage,
+                                                 self._stageview)
+            dialog.show()
+
+        actions["Snapshot View"].triggered.connect(render_snap)
+        actions["Snapshot Framing Camera"].triggered.connect(render_snap_framed)
+        actions["Playblast Stage"].triggered.connect(playblast_stage_dialog)
+        actions["Turntable Stage"].triggered.connect(turntable_stage_dialog)

usd_qtpy/lib/qt.py

@@ -1,6 +1,7 @@
 import re
 import sys
 import logging
+from functools import wraps
 from qtpy import QtCore, QtGui, QtWidgets
 
 
@@ -55,6 +56,7 @@ def report_error(fn):
     `Tf.Notice` registry because those do not output the errors that occur.
 
     """
+    @wraps(fn) # keep signature and docstring of decorated function intact.
     def wrap(*args, **kwargs):
         try:
             return fn(*args, **kwargs)

usd_qtpy/lib/usd.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from typing import Union
 
 from pxr import Usd, Plug, Tf, Sdf
 import logging
@@ -319,4 +320,4 @@ def remove_spec(spec):
         spec.owner.RemoveVariant(spec)
 
     else:
-        raise TypeError(f"Unsupported spec type: {spec}")
+        raise TypeError(f"Unsupported spec type: {spec}")

usd_qtpy/render_util/__init__.py

@@ -0,0 +1,54 @@
+from .base import (
+    RenderReportable,
+)
+from .dialog import (
+    prompt_input_path,
+    prompt_output_path,
+    PlayblastDialog,
+    TurntableDialog,
+)
+from .framing_camera import (
+    get_stage_up,
+    create_framing_camera_in_stage,
+    camera_conform_sensor_to_aspect,
+)
+from .playblast import (
+    camera_from_stageview,
+    iter_stage_cameras,
+    get_file_cameras,
+    get_frames_string,
+    tuples_to_frames_string,
+    render_playblast,
+)
+from .turntable import (
+    create_turntable_xform,
+    create_turntable_camera,
+    get_turntable_frames_string,
+    turntable_from_preset
+)
+
+
+__all__ = [
+    "RenderReportable",
+
+    "prompt_input_path",
+    "prompt_output_path",
+    "PlayblastDialog",
+    "TurntableDialog",
+
+    "get_stage_up",
+    "create_framing_camera_in_stage",
+    "camera_conform_sensor_to_aspect",
+
+    "camera_from_stageview",
+    "iter_stage_cameras",
+    "get_file_cameras",
+    "get_frames_string",
+    "tuples_to_frames_string",
+    "render_playblast",
+
+    "create_turntable_xform",
+    "create_turntable_camera",
+    "get_turntable_frames_string",
+    "turntable_from_preset"
+]

usd_qtpy/render_util/base.py

@@ -0,0 +1,33 @@
+# Provides mixins and classes to be inherited from, as well as decorators
+import os
+from contextlib import contextmanager
+from typing import Union
+
+from qtpy import QtCore
+from pxr import Usd, Sdf
+
+
+@contextmanager
+def defer_file_deletion(path: str):
+    try:
+        yield None
+    finally:
+        os.remove(path)
+
+
+@contextmanager
+def defer_primpath_deletion(stage: Usd.Stage, path: Union[str, Sdf.Path]):
+    if isinstance(path, str):
+        path = Sdf.Path(path)
+    try:
+        yield None
+    finally:
+        stage.RemovePrim(path)
+
+
+class RenderReportable:
+    """
+    Mixin class to set up signals for everything needing slots.
+    """
+    render_progress = QtCore.Signal(int)
+    total_frames = QtCore.Signal(int)