fix(app): split renderings into two @GPU callbacks; lower defaults

- Split generate_renderings into generate_videos + generate_glb.
Each gets its own @GPU callback so the heavy mesh simplification
in GLB export does not blow the 120 s ZeroGPU lease.
- Lower default num_cam / num_hdri from 36 → 24.
- Lower default texture_size from 2048 → 1024.
- UI: make both buttons visible and wire them independently.

app.py

@@ -534,7 +534,7 @@ def load_slat_file(
 
 @GPU
 @torch.no_grad()
-def generate_renderings(
+def generate_videos(
     asset_state: Dict[str, Any],
     hdri_file_obj: Any,
     hdri_rot: float,
@@ -545,29 +545,98 @@ def generate_renderings(
     pitch: float,
     fov: float,
     radius: float,
+    req: gr.Request,
+    progress: gr.Progress = gr.Progress(track_tqdm=True),
+) -> tuple[str, str, str, str]:
+    """③ Render camera-orbit + HDRI-rotation videos.
+
+    Kept as a separate @GPU callback so it fits inside the 120 s ZeroGPU lease.
+    Returns: (cam_video, hdri_video, roll_video, status_msg)
+    """
+    slat_path = _require_slat(asset_state)
+    hdri_path = _require_hdri(hdri_file_obj)
+    session_dir = CACHE_DIR / str(req.session_hash)
+
+    progress(0.05, desc="Loading NeAR on GPU")
+    pipe = _ensure_near_on_cuda()
+
+    progress(0.20, desc="Loading SLaT / HDRI")
+    slat = pipe.load_slat(slat_path)
+    hdri_np = _load_hdri_resized(pipe, hdri_path)
+
+    # ── Camera-orbit video ────────────────────────────────────────────
+    progress(0.30, desc="Rendering camera-orbit video…")
+    cam_frames = pipe.render_camera_path_video(
+        slat, hdri_np,
+        num_views=int(num_cam),
+        fov=float(fov), radius=float(radius),
+        hdri_rot_deg=float(hdri_rot),
+        full_video=True,
+        shadow_video=True,
+        bg_color=(1, 1, 1),
+        verbose=True,
+    )
+    p_cam = session_dir / "video_camera_orbit.mp4"
+    imageio.mimsave(p_cam, cam_frames, fps=int(fps))
+    del cam_frames
+    _free_cuda()
+
+    # ── HDRI-rotation videos ──────────────────────────────────────────
+    progress(0.65, desc="Rendering HDRI-rotation video…")
+    roll_frames, hdri_frames = pipe.render_hdri_rotation_video(
+        slat, hdri_np,
+        num_frames=int(num_hdri),
+        yaw_deg=float(yaw), pitch_deg=float(pitch),
+        fov=float(fov), radius=float(radius),
+        full_video=True,
+        shadow_video=True,
+        bg_color=(1, 1, 1),
+        verbose=True,
+    )
+    p_hdri = session_dir / "video_hdri_rotation.mp4"
+    p_roll = session_dir / "video_env_roll.mp4"
+    imageio.mimsave(p_hdri, hdri_frames, fps=int(fps))
+    imageio.mimsave(p_roll, roll_frames, fps=int(fps))
+    del hdri_frames, roll_frames, slat, hdri_np
+    _free_cuda()
+
+    _teardown_near()
+
+    msg = (
+        f"**③ Videos ready** → `{Path(p_cam).name}`, "
+        f"`{Path(p_hdri).name}`, `{Path(p_roll).name}`"
+    )
+    return str(p_cam), str(p_hdri), str(p_roll), msg
+
+
+@GPU
+@torch.no_grad()
+def generate_glb(
+    asset_state: Dict[str, Any],
+    hdri_file_obj: Any,
+    hdri_rot: float,
     simplify: float,
     texture_size: int,
     req: gr.Request,
     progress: gr.Progress = gr.Progress(track_tqdm=True),
-) -> tuple[str, str, str, str, str]:
-    """③④ Unified rendering pipeline: videos + PBR GLB in ONE CUDA context.
-    
-    This merged callback avoids ZeroGPU CUDA context resets between steps.
-    Returns: (cam_video, hdri_video, roll_video, pbr_glb, status_msg)
+) -> tuple[str, str]:
+    """④ Export PBR GLB (baked texture + simplified mesh).
+
+    Separate @GPU callback so the heavy mesh simplification does not
+    blow the 120 s budget shared with video rendering.
+    Returns: (pbr_glb, status_msg)
     """
     slat_path = _require_slat(asset_state)
     hdri_path = _require_hdri(hdri_file_obj)
     session_dir = CACHE_DIR / str(req.session_hash)
 
-    # ── Load NeAR once (fresh CUDA context) ───────────────────────────
     progress(0.05, desc="Loading NeAR on GPU")
     pipe = _ensure_near_on_cuda()
 
-    progress(0.08, desc="Loading SLaT / HDRI")
+    progress(0.15, desc="Loading SLaT / HDRI / mesh")
     slat = pipe.load_slat(slat_path)
     hdri_np = _load_hdri_resized(pipe, hdri_path)
 
-    # ── Prepare base mesh (optional, for GLB export) ────────────────────
     mesh_path = asset_state.get("mesh_path")
     base_mesh: Optional[trimesh.Trimesh] = None
     if mesh_path and os.path.isfile(mesh_path):
@@ -579,46 +648,7 @@ def generate_renderings(
     else:
         print("[NeAR] no mesh_path — will use SLaT decoder mesh for GLB", flush=True)
 
-    # ── Render videos ──────────────────────────────────────────────────
-    progress(0.12, desc="Rendering camera-orbit video…")
-    with torch.no_grad():
-        cam_frames = pipe.render_camera_path_video(
-            slat, hdri_np,
-            num_views=int(num_cam),
-            fov=float(fov), radius=float(radius),
-            hdri_rot_deg=float(hdri_rot),
-            full_video=True,
-            shadow_video=True,
-            bg_color=(1, 1, 1),
-            verbose=True,
-        )
-    p_cam = session_dir / "video_camera_orbit.mp4"
-    imageio.mimsave(p_cam, cam_frames, fps=int(fps))
-    del cam_frames
-    _free_cuda()  # Free GPU mem temporarily while still in same CUDA context
-
-    progress(0.55, desc="Rendering HDRI-rotation video…")
-    with torch.no_grad():
-        roll_frames, hdri_frames = pipe.render_hdri_rotation_video(
-            slat, hdri_np,
-            num_frames=int(num_hdri),
-            yaw_deg=float(yaw), pitch_deg=float(pitch),
-            fov=float(fov), radius=float(radius),
-            full_video=True,
-            shadow_video=True,
-            bg_color=(1, 1, 1),
-            verbose=True,
-        )
-    p_hdri = session_dir / "video_hdri_rotation.mp4"
-    p_roll = session_dir / "video_env_roll.mp4"
-    imageio.mimsave(p_hdri, hdri_frames, fps=int(fps))
-    imageio.mimsave(p_roll, roll_frames, fps=int(fps))
-    del hdri_frames, roll_frames
-    _free_cuda()
-
-    # ── Export PBR GLB ────────────────────────────────────────────────
-    # (renderer/tone_mapper still valid in same CUDA context)
-    progress(0.85, desc="Baking PBR GLB…")
+    progress(0.30, desc="Baking PBR GLB…")
     glb = pipe.export_glb_from_slat(
         slat, hdri_np,
         hdri_rot_deg=float(hdri_rot),
@@ -634,15 +664,10 @@ def generate_renderings(
     glb.export(out_path)
     del glb
 
-    # ── Cleanup: tear down NeAR before exiting CUDA callback ────────────
     _teardown_near()
 
-    msg = (
-        f"**③ Videos ready** → `{Path(p_cam).name}`, "
-        f"`{Path(p_hdri).name}`, `{Path(p_roll).name}` \n\n"
-        f"**④ PBR GLB ready** → `{Path(out_path).name}`"
-    )
-    return str(p_cam), str(p_hdri), str(p_roll), str(out_path), msg
+    msg = f"**④ PBR GLB ready** → `{Path(out_path).name}`"
+    return str(out_path), msg
 
 
 def _hunyuan_mesh_to_renderer_space(mesh: trimesh.Trimesh) -> trimesh.Trimesh:
@@ -821,12 +846,12 @@ def build_app() -> gr.Blocks:
                 hdri_rot = gr.Slider(0, 360, value=0, step=1, label="HDRI rotation °")
 
                 gr.HTML('<p class="section-kicker" style="margin:2px 0 2px;padding:0">Actions</p>')
-                btn_videos = gr.Button("③④ Generate Videos & GLB", variant="primary")
-                btn_glb = gr.Button("④ Export PBR GLB", variant="primary", visible=False)
+                btn_videos = gr.Button("③ Generate Videos", variant="primary")
+                btn_glb = gr.Button("④ Export PBR GLB", variant="primary")
                 with gr.Accordion("Video / export settings", open=False):
                     fps = gr.Slider(8, 48, value=24, step=1, label="FPS")
-                    num_cam = gr.Slider(8, 96, value=36, step=4, label="Camera-orbit frames")
-                    num_hdri = gr.Slider(8, 96, value=36, step=4, label="HDRI-rotation frames")
+                    num_cam = gr.Slider(8, 96, value=24, step=4, label="Camera-orbit frames")
+                    num_hdri = gr.Slider(8, 96, value=24, step=4, label="HDRI-rotation frames")
                     with gr.Row():
                         yaw = gr.Slider(0, 360, value=0, step=1, label="Yaw °")
                         pitch = gr.Slider(-90, 90, value=0, step=1, label="Pitch °")
@@ -834,7 +859,7 @@ def build_app() -> gr.Blocks:
                         fov = gr.Slider(10, 70, value=40, step=1, label="FoV")
                         radius = gr.Slider(1.0, 4.0, value=2.0, step=0.05, label="Radius")
                     simplify = gr.Slider(0.80, 0.99, value=0.95, step=0.01, label="GLB simplify ratio")
-                    tex_size = gr.Slider(512, 4096, value=2048, step=512, label="Texture resolution")
+                    tex_size = gr.Slider(512, 2048, value=1024, step=512, label="Texture resolution")
                 btn_clear = gr.Button("Clear session cache", variant="secondary")
 
             # ── CENTER: linear output area ────────────────────────────────────
@@ -888,10 +913,12 @@ def build_app() -> gr.Blocks:
                        [asset_state, status])
         btn_load_slat.click(load_slat_file, [slat_upload, slat_path_txt],
                             [asset_state, status])
-        # ③④ Unified render callback: videos + GLB in ONE CUDA context
-        btn_videos.click(generate_renderings,
-                         [asset_state, hdri_file, hdri_rot, fps, num_cam, num_hdri, yaw, pitch, fov, radius, simplify, tex_size],
-                         [vid_cam, vid_hdri, vid_roll, glb_view, status])
+        btn_videos.click(generate_videos,
+                         [asset_state, hdri_file, hdri_rot, fps, num_cam, num_hdri, yaw, pitch, fov, radius],
+                         [vid_cam, vid_hdri, vid_roll, status])
+        btn_glb.click(generate_glb,
+                      [asset_state, hdri_file, hdri_rot, simplify, tex_size],
+                      [glb_view, status])
         btn_clear.click(clear_cache, [], [status])
 
     return demo