Show real GLB extraction stages and elapsed time; add seven TRELLIS.2 HDR preview modes

.gitattributes

@@ -50,3 +50,6 @@ assets/supratex_fighter_typography.mp4 filter=lfs diff=lfs merge=lfs -text
 assets/fighter.png filter=lfs diff=lfs merge=lfs -text
 
 assets/urban_gardener.png filter=lfs diff=lfs merge=lfs -text
+assets/preview-lighting/courtyard.exr filter=lfs diff=lfs merge=lfs -text
+assets/preview-lighting/forest.exr filter=lfs diff=lfs merge=lfs -text
+assets/preview-lighting/sunset.exr filter=lfs diff=lfs merge=lfs -text

app.py

@@ -48,8 +48,8 @@ def process_image_generator(input_image, seed=42, generation_token=None, progres
 
 
 @spaces.GPU(duration=600, size='large')
-def extract_glb(identifier):
-    return ovoxel_results.extract(identifier)
+def extract_glb(identifier, extraction_token=None):
+    return ovoxel_results.extract(identifier, extraction_token)
 
 
 from hf_space.ui import build_ui, CSS, THEME

assets/preview-lighting/README.md

@@ -0,0 +1,6 @@
+HDR environment maps and render-mode swatches from Microsoft's TRELLIS.2 Space,
+revision ebf60b20fc5a4607f90a1c11c0aab0ceeda5429d:
+https://huggingface.co/spaces/microsoft/TRELLIS.2/tree/ebf60b20fc5a4607f90a1c11c0aab0ceeda5429d/assets
+
+Environment-map attribution is retained in license.txt. The four HDR files are
+used by the original TRELLIS.2 PbrMeshRenderer / nvdiffrec environment-light backend.

assets/preview-lighting/license.txt

@@ -0,0 +1,15 @@
+All HDRIs are licensed as CC0.
+
+These were created by Greg Zaal (Poly Haven https://polyhaven.com).
+Originals used for each HDRI:
+- City: https://polyhaven.com/a/portland_landing_pad
+- Courtyard: https://polyhaven.com/a/courtyard
+- Forest: https://polyhaven.com/a/ninomaru_teien
+- Interior: https://polyhaven.com/a/hotel_room
+- Night: Probably https://polyhaven.com/a/moonless_golf
+- Studio: Probably https://polyhaven.com/a/studio_small_01
+- Sunrise: https://polyhaven.com/a/spruit_sunrise
+- Sunset: https://polyhaven.com/a/venice_sunset
+
+1K resolution of each was taken, and compressed with oiiotool:
+oiiotool input.exr --ch R,G,B -d float --compression dwab:300 --clamp:min=0.0:max=32000.0 -o output.exr

hf_space/extraction_progress.py

@@ -0,0 +1,52 @@
+"""Cross-process GLB extraction stages, polled independently of the GPU queue."""
+import html
+import time
+from hf_space import generation_progress as records
+
+# These are completed workflow stages, not a prediction of remaining time.
+STAGES = {
+    'load': (0, 'Loading o-voxel data'),
+    'export_prepare': (1, 'Preparing GLB export'),
+    'mesh_prepare': (1, 'Preparing the mesh'),
+    'initial_cleanup': (1, 'Cleaning the mesh'),
+    'bvh': (2, 'Building surface acceleration'),
+    'cleanup': (2, 'Remeshing and simplifying'),
+    'uv_unwrap': (3, 'Unwrapping UVs'),
+    'texture_sample': (4, 'Baking 4096 px PBR textures'),
+    'finalize': (5, 'Preparing PBR materials'),
+    'file_write': (6, 'Writing GLB'),
+    'validate': (7, 'Validating GLB'),
+}
+TOTAL = 8
+
+
+def start():
+    token = records.start()
+    records.update(token, label='Waiting for GPU', completed=0)
+    return token
+
+
+def stage(token, name):
+    if name in STAGES:
+        completed, label = STAGES[name]
+        records.update(token, status='running', label=label, completed=completed)
+
+
+def finish(token, failed=False):
+    records.update(token, status='failed' if failed else 'complete',
+                   label='Extraction failed — please retry' if failed else 'GLB ready to download',
+                   **({} if failed else {'completed': TOTAL}), finished_unix=time.time())
+
+
+def status_html(token):
+    record = records._read(token)
+    if not record:
+        return ''
+    elapsed = max(0, record.get('finished_unix', time.time()) - record['started_unix'])
+    completed = record.get('completed', 0)
+    label = html.escape(record.get('label', 'Waiting for GPU'))
+    status = html.escape(record.get('status', 'queued'), quote=True)
+    return (f'<div class="st-extraction-progress {status}" role="status" aria-live="polite">'
+            f'<div><strong>{label}</strong><span>Elapsed: {int(elapsed)} s</span></div>'
+            f'<progress max="{TOTAL}" value="{completed}" aria-label="GLB extraction stages"></progress>'
+            f'<small>{completed} / {TOTAL} stages complete</small></div>')

hf_space/native_build.py

@@ -113,10 +113,14 @@ def build():
         wheels.mkdir(exist_ok=True)
         pip = [sys.executable, '-m', 'pip']
         completed = []
-        for name, url, revision, subdir in SOURCES:
+        preview_sources = ((
+            'nvdiffrec', 'https://github.com/JeffreyXiang/nvdiffrec.git',
+            'b296927cc7fd01c2ac1087c8065c4d7248f72da4', ''),)
+        for name, url, revision, subdir in (*SOURCES, *preview_sources):
             update(stage='compiling', current=name, completed=completed)
             # Wheel distribution names differ from the public repository names.
-            distribution = {'CuMesh': 'cumesh', 'FlexGEMM': 'flex_gemm', 'nvdiffrast': 'nvdiffrast', 'TRELLIS.2': 'o_voxel'}[name]
+            distribution = {'CuMesh': 'cumesh', 'FlexGEMM': 'flex_gemm', 'nvdiffrast': 'nvdiffrast',
+                            'TRELLIS.2': 'o_voxel', 'nvdiffrec': 'nvdiffrec_render'}[name]
             cached = list(persistent.glob(distribution + '-*.whl'))
             if cached:
                 local = wheels / cached[0].name

hf_space/ovoxel_preview.js

@@ -6,7 +6,9 @@
       image.hidden = image.dataset.mode !== root.dataset.mode || image.dataset.view !== root.dataset.view;
     });
     root.querySelectorAll('.st-ovoxel-modes button').forEach(button => {
-      button.classList.toggle('active', button.dataset.mode === root.dataset.mode);
+      const active = button.dataset.mode === root.dataset.mode;
+      button.classList.toggle('active', active);
+      button.setAttribute('aria-pressed', String(active));
     });
   };
   document.addEventListener('input', event => {

hf_space/ovoxel_preview.py

@@ -1,36 +1,36 @@
 """Render the final decoded o-voxel directly, before UV or GLB extraction.
 
-Uses TRELLIS.2's bundled render_snapshot/PbrMeshRenderer, with analytic studio
-lighting so preview does not require an extra HDR environment dependency.
+Uses TRELLIS.2's PbrMeshRenderer and HDR environments for material inspection.
 """
 import json
 from pathlib import Path
 from hf_space.timing import span
 
 
-class StudioLight:
-    def shade(self, pos, normal, kd, ks, view_pos, specular=True):
-        import torch
-        import torch.nn.functional as F
-        n = F.normalize(normal, dim=-1)
-        light = F.normalize(n.new_tensor([-.4, .8, 1.]), dim=0)
-        diffuse = (n*light).sum(-1, keepdim=True).clamp(0, 1)
-        color = kd*(.55+.45*diffuse)
-        if specular:
-            view = F.normalize(view_pos-pos, dim=-1)
-            half = F.normalize(view+light, dim=-1)
-            rough = ks[..., 1:2].clamp(.08, 1)
-            metal = ks[..., 2:3].clamp(0, 1)
-            highlight = (n*half).sum(-1, keepdim=True).clamp(0, 1).pow(2/rough.square())
-            color += highlight*(.04*(1-metal)+kd*metal)*.4
-        return color
+ENVIRONMENTS = ('studio', 'forest', 'sunset', 'courtyard')
+
+
+def load_environments():
+    import os
+    os.environ['OPENCV_IO_ENABLE_OPENEXR'] = '1'
+    import cv2
+    import torch
+    from supratex.renderers import EnvMap
+    folder = Path(__file__).resolve().parents[1]/'assets/preview-lighting'
+    environments = {}
+    for name in ENVIRONMENTS:
+        image = cv2.imread(str(folder/f'{name}.exr'), cv2.IMREAD_UNCHANGED)
+        if image is None:
+            raise RuntimeError(f'Could not load HDR environment: {name}')
+        environments[name] = EnvMap(torch.tensor(cv2.cvtColor(image, cv2.COLOR_BGR2RGB),
+                                                dtype=torch.float32, device='cuda'))
+    return environments
 
 
 def save_and_render(output, representation):
     import numpy as np
     import torch
     from PIL import Image
-    from supratex.utils.render_utils import render_snapshot
     if representation.vertices.device.type != 'cuda':
         raise RuntimeError('Multiview rendering requires CUDA')
     output = Path(output)
@@ -54,20 +54,21 @@ def save_and_render(output, representation):
         extrinsics = [matrix@rotation for matrix in extrinsics]
         with torch.no_grad():
             frames = render_frames(representation, extrinsics, intrinsics,
-                options={'resolution':768,'ssaa':1,'peel_layers':2}, envmap=StudioLight())
+                options={'resolution':768,'ssaa':1,'peel_layers':2}, envmap=load_environments())
         folder = output.parent/'views'
         folder.mkdir(exist_ok=True)
-        modes = ('shaded','base_color','normal')
+        modes = ('normal','clay','base_color',*(f'shaded_{name}' for name in ENVIRONMENTS))
         for mode in modes:
             for index, pixels in enumerate(frames[mode]):
                 mask = frames['mask'][index][..., :1].astype(np.float32)/255
                 # Composite the same neutral background in every view.
-                if mode == 'shaded':
+                if mode.startswith('shaded_'):
                     pixels = np.clip(pixels.astype(np.float32)+(1-mask)*25,0,255).astype(np.uint8)
                 else:
                     pixels = np.clip(pixels*mask+(1-mask)*25,0,255).astype(np.uint8)
                 Image.fromarray(pixels).save(folder/f'{mode}-{index:02d}.webp',quality=90)
         (output.parent/'preview.json').write_text(json.dumps({
             'views':count,'modes':list(modes),'resolution':768,'device':'cuda',
-            'renderer':'TRELLIS.2 PbrMeshRenderer','lighting':'analytic studio',
+            'renderer':'TRELLIS.2 PbrMeshRenderer','lighting':'HDR image-based lighting',
+            'environments':list(ENVIRONMENTS),'default_mode':'shaded_forest',
             'automatic_glb_export':False}))

hf_space/ovoxel_results.py

@@ -3,8 +3,20 @@ import json
 from pathlib import Path
 import re
 import shutil
+from html import escape
 from urllib.parse import quote
 
+PREVIEW_MODES = (
+    ('normal', 'Normal', 'normal.png'),
+    ('clay', 'Clay', 'clay.png'),
+    ('base_color', 'Base color', 'basecolor.png'),
+    ('shaded_studio', 'HDRI Studio', 'hdri_studio.png'),
+    ('shaded_forest', 'HDRI Forest', 'hdri_forest.png'),
+    ('shaded_sunset', 'HDRI Sunset', 'hdri_sunset.png'),
+    ('shaded_courtyard', 'HDRI Courtyard', 'hdri_courtyard.png'),
+    ('shaded', 'Studio', 'hdri_studio.png'),  # Previously saved previews.
+)
+
 ROOT = Path('/data/generated/ovoxel-results-v1')
 
 
@@ -30,21 +42,50 @@ def persist(source, report):
 def preview_html(identifier):
     root = directory(identifier)
     metadata = json.loads((root/'preview.json').read_text())
+    default = metadata.get('default_mode', 'shaded' if 'shaded' in metadata['modes'] else 'shaded_forest')
+    if default not in metadata['modes']:
+        default = metadata['modes'][0]
     images = []
     for mode in metadata['modes']:
         for view in range(metadata['views']):
             url = '/gradio_api/file='+quote(str(root/'views'/f'{mode}-{view:02d}.webp'),safe='/')
-            hidden = '' if mode == 'shaded' and view == 0 else ' hidden'
+            hidden = '' if mode == default and view == 0 else ' hidden'
             images.append(f'<img src="{url}" data-mode="{mode}" data-view="{view}" alt="{mode.replace("_"," ")} view {view+1}"{hidden}>')
-    return ('<div class="st-ovoxel-preview" data-mode="shaded" data-view="0">'
+    buttons = []
+    for mode, label, icon in PREVIEW_MODES:
+        if mode not in metadata['modes']:
+            continue
+        # Inline the tiny swatches; preview frames remain individually cached files.
+        import base64
+        icon_path = Path(__file__).resolve().parents[1]/'assets/preview-lighting'/icon
+        swatch = base64.b64encode(icon_path.read_bytes()).decode('ascii')
+        active = mode == default
+        buttons.append(f'<button type="button" data-mode="{mode}" class="{"active" if active else ""}" '
+            f'title="{label}" aria-label="{label}" aria-pressed="{str(active).lower()}">'
+            f'<img src="data:image/png;base64,{swatch}" alt=""><span class="st-mode-name">{label}</span></button>')
+    return (f'<div class="st-ovoxel-preview" data-mode="{escape(default, quote=True)}" data-view="0">'
         '<div class="st-ovoxel-frames">'+''.join(images)+'</div>'
-        '<div class="st-ovoxel-modes"><button type="button" data-mode="shaded" class="active">Studio</button>'
-        '<button type="button" data-mode="base_color">Base color</button>'
-        '<button type="button" data-mode="normal">Normal</button></div>'
+        '<div class="st-ovoxel-modes" role="group" aria-label="Render mode">'+''.join(buttons)+'</div>'
         f'<label class="st-ovoxel-angle">View angle <input type="range" min="0" max="{metadata["views"]-1}" value="0" step="1" aria-label="View angle"></label></div>')
 
 
-def extract(identifier):
+def extract(identifier, extraction_token=None):
+    from hf_space import extraction_progress as progress
+    from hf_space import generation_progress
+    from hf_space.timing import observe_stages
+    token = extraction_token if generation_progress.valid(extraction_token) else progress.start()
+    try:
+        progress.stage(token, 'load')
+        with observe_stages(lambda name: progress.stage(token, name)):
+            output = _extract(identifier, token)
+        progress.finish(token)
+        return output
+    except Exception:
+        progress.finish(token, failed=True)
+        raise
+
+
+def _extract(identifier, token):
     """Runs only inside the explicitly requested GPU extraction callback."""
     root = directory(identifier)
     if not (root/'ready.json').is_file():
@@ -67,6 +108,8 @@ def extract(identifier):
     import time
     started = time.monotonic()
     _export(output, representation,4096,500000,'png',_runtime())
+    from hf_space import extraction_progress
+    extraction_progress.stage(token, 'validate')
     from hf_space.backend import validate_glb
     metadata = validate_glb(output)
     (root/'extraction.json').write_text(json.dumps({'status':'complete','device':'cuda',

hf_space/timing.py

@@ -9,6 +9,17 @@ import time
 import uuid
 
 _current = ContextVar('supratex_timing_span', default=None)
+_observer = ContextVar('supratex_stage_observer', default=None)
+
+
+@contextmanager
+def observe_stages(callback):
+    """Report actual stage starts within this request, even without a timing log."""
+    token = _observer.set(callback)
+    try:
+        yield
+    finally:
+        _observer.reset(token)
 
 
 def _sync_cuda():
@@ -33,6 +44,9 @@ def _record(path, data):
 
 @contextmanager
 def span(name):
+    callback = _observer.get()
+    if callback is not None:
+        callback(name)
     path = os.environ.get('SUPRATEX_TIMING_PATH')
     if not path:
         yield

hf_space/ui.css

@@ -180,12 +180,25 @@
 #st-app .st-ovoxel-frames{position:relative;flex:1;min-height:230px;overflow:hidden}
 #st-app .st-ovoxel-frames img{position:absolute;inset:0;width:100%;height:100%;object-fit:contain}
 #st-app .st-ovoxel-frames img[hidden]{display:none!important}
-#st-app .st-ovoxel-modes{display:flex;justify-content:center;gap:10px}
-#st-app .st-ovoxel-modes button{padding:7px 14px;border:1px solid #484846;border-radius:20px;background:#252523;color:#ccc;font-size:12px}
-#st-app .st-ovoxel-modes button.active{color:#f2cd70;border-color:#f2cd70}
+#st-app .st-ovoxel-modes{display:flex;justify-content:center;gap:12px;flex-wrap:wrap;padding:4px}
+#st-app .st-ovoxel-modes button{position:relative;padding:2px;width:34px;height:34px;border:2px solid transparent;border-radius:50%;background:#252523;color:#ccc;cursor:pointer}
+#st-app .st-ovoxel-modes button img{width:100%;height:100%;border-radius:50%;object-fit:cover}
+#st-app .st-ovoxel-modes button.active{border-color:#f2cd70;box-shadow:0 0 0 2px #f2cd7024}
+#st-app .st-ovoxel-modes button:focus-visible{outline:2px solid #f2cd70;outline-offset:4px}
+#st-app .st-mode-name{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%)}
 #st-app .st-ovoxel-angle{display:flex;align-items:center;gap:14px;color:#aaa;font-size:12px}
 #st-app .st-ovoxel-angle input{flex:1;accent-color:#f2cd70}
 #st-extract{flex:0 0 auto!important}
+#st-download,#st-extraction-progress{flex:0 0 auto!important}
+#st-app .st-extraction-progress{display:flex;flex-direction:column;gap:8px;padding:12px 16px;border:1px solid #484438;border-radius:10px;background:#22211e;color:#ddd8cd;font-size:12px}
+#st-app .st-extraction-progress>div{display:flex;justify-content:space-between;gap:12px;flex-wrap:wrap}
+#st-app .st-extraction-progress strong{font-weight:500}
+#st-app .st-extraction-progress span{color:#aaa;font-variant-numeric:tabular-nums}
+#st-app .st-extraction-progress progress{width:100%;height:5px;accent-color:#f2cd70;border:0;border-radius:5px;overflow:hidden;background:#35322b}
+#st-app .st-extraction-progress progress::-webkit-progress-bar{background:#35322b}
+#st-app .st-extraction-progress progress::-webkit-progress-value{background:#f2cd70}
+#st-app .st-extraction-progress small{color:#aaa;font-size:11px}
+#st-app .st-extraction-progress.failed{border-color:#c36f67}
 #st-app .st-extraction-note{font-size:14px;line-height:1.6;color:#999;text-align:center}
 @media(max-width:700px){#st-ovoxel{height:370px;flex:auto!important}}
 #st-output-panel{position:relative}

hf_space/ui.py

@@ -3,7 +3,7 @@ from pathlib import Path
 import os
 import gradio as gr
 from PIL import Image
-from hf_space import generation_progress, startup_progress
+from hf_space import generation_progress, startup_progress, extraction_progress
 
 ROOT = Path(__file__).resolve().parents[1]
 CSS = Path(__file__).with_name('ui.css').read_text(encoding='utf-8')
@@ -102,6 +102,8 @@ def build_ui(generate, deployment_status, *, cached_result, default_image=None,
         input_present = gr.State(default_image is not None)
         generated_asset = gr.Textbox(value='',visible=False)
         progress_timer = gr.Timer(1, active=False)
+        extraction_token = gr.State('')
+        extraction_timer = gr.Timer(1, active=False)
         with gr.Column(elem_id='st-app'):
             html(HEADER, elem_id='st-header')
             with gr.Row(elem_id='st-workspace', equal_height=False):
@@ -138,22 +140,25 @@ def build_ui(generate, deployment_status, *, cached_result, default_image=None,
                                              clear_color=(0.098, 0.098, 0.098, 1), elem_id='st-model')
                     render_output = html('',visible='hidden',elem_id='st-ovoxel')
                     extract_btn = gr.Button('Extract GLB',interactive=False,elem_id='st-extract')
+                    extraction_status = html('', visible='hidden', elem_id='st-extraction-progress')
+                    download_btn = gr.DownloadButton('Download GLB', visible='hidden', elem_id='st-download')
                     html('<div class="st-extraction-note">Initial geometry generation can take longer. GLB extraction can also be slow.</div>',elem_id='st-extraction-note')
             status_output = gr.JSON(visible=False)
             refresh = gr.Button(visible=False)
 
             def select_example(current_phase, evt: gr.SelectData):
-                if current_phase == 'running':
-                    raise gr.Error('Please wait for the current generation to finish.')
+                if current_phase in ('running', 'extracting'):
+                    raise gr.Error('Please wait for the current operation to finish.')
                 path = examples[int(evt.index)][0]
                 with Image.open(path) as image:
                     model = cached_result(image, 42)
                 return (path, 42, gr.update(value=model, visible=True if model is not None else 'hidden'),
                         gr.update(visible=True if model is None else 'hidden'), 'idle', gr.update(value='', visible='hidden'),
-                        gr.update(value='',visible='hidden'),'',gr.update(interactive=False))
+                        gr.update(value='',visible='hidden'),'',gr.update(interactive=False),
+                        gr.update(value=None,visible='hidden'),gr.update(value='',visible='hidden'))
 
             if examples:
-                gallery.select(select_example, [phase], [input_image, seed, mesh_output, empty, phase, estimate,render_output,generated_asset,extract_btn],
+                gallery.select(select_example, [phase], [input_image, seed, mesh_output, empty, phase, estimate,render_output,generated_asset,extract_btn,download_btn,extraction_status],
                                api_visibility='private', queue=False)
             if examples_status:
                 example_trigger = gr.Button(visible=False)
@@ -163,12 +168,12 @@ def build_ui(generate, deployment_status, *, cached_result, default_image=None,
                 state = deployment_status()
                 usable = available(state, image, current_seed)
                 status = gr.update(value='', visible='hidden') if usable and current_phase != 'failed' else status_label(state, current_phase)
-                return state, gr.update(interactive=usable and current_phase != 'running'), status, image is not None
+                return state, gr.update(interactive=usable and current_phase not in ('running', 'extracting')), status, image is not None
 
             def sync_startup(current_phase, has_image):
                 state = deployment_status()
                 usable = ready(state) and has_image
-                return state, gr.update(interactive=usable and current_phase != 'running'), status_label(state, current_phase)
+                return state, gr.update(interactive=usable and current_phase not in ('running', 'extracting')), status_label(state, current_phase)
 
             def begin(image, current_seed):
                 if image is None:
@@ -178,7 +183,8 @@ def build_ui(generate, deployment_status, *, cached_result, default_image=None,
                         gr.update(value=None, visible='hidden'), gr.update(visible=True),
                         gr.update(value=generation_progress.overlay_html(token, estimated_seconds), visible=True),
                         token, gr.update(active=True), generation_progress.status_html(token),
-                        gr.update(value='',visible='hidden'),'',gr.update(interactive=False))
+                        gr.update(value='',visible='hidden'),'',gr.update(interactive=False),
+                        gr.update(value=None,visible='hidden'),gr.update(value='',visible='hidden'))
 
             def finish(image, current_seed):
                 usable = available(deployment_status(), image, current_seed)
@@ -202,7 +208,7 @@ def build_ui(generate, deployment_status, *, cached_result, default_image=None,
                 return gr.update(value=rendered, visible=True), identifier
 
             start = generate_btn.click(begin, [input_image, seed],
-                [phase, generate_btn, live_status, mesh_output, empty, estimate, generation_token, progress_timer, progress_state,render_output,generated_asset,extract_btn],
+                [phase, generate_btn, live_status, mesh_output, empty, estimate, generation_token, progress_timer, progress_state,render_output,generated_asset,extract_btn,download_btn,extraction_status],
                 queue=False, api_visibility='private')
             run = start.then(generate_preview, [input_image, seed, generation_token], [render_output,generated_asset], api_name='generate',
                              concurrency_limit=1, concurrency_id='supra-tex-gpu', show_progress='hidden')
@@ -214,15 +220,31 @@ def build_ui(generate, deployment_status, *, cached_result, default_image=None,
                 def begin_extract(identifier):
                     if not identifier:
                         raise gr.Error('Generate a new asset before extracting GLB.')
-                    return gr.update(interactive=False)
-                def display_extraction(identifier):
-                    return gr.update(value=extract_glb(identifier),visible=True)
-                extraction = extract_btn.click(begin_extract,[generated_asset],extract_btn,queue=False,api_visibility='private')
-                extraction = extraction.then(display_extraction,[generated_asset],mesh_output,api_name='extract_glb',
-                    concurrency_limit=1,concurrency_id='supra-tex-gpu',show_progress='minimal')
-                extraction.success(lambda:(gr.update(visible='hidden'),gr.update(interactive=True)),
-                    [],[render_output,extract_btn],queue=False,api_visibility='private')
-                extraction.failure(lambda:gr.update(interactive=True),[],extract_btn,queue=False,api_visibility='private')
+                    token = extraction_progress.start()
+                    return ('extracting', gr.update(interactive=False), gr.update(interactive=False),
+                            token, gr.update(active=True),
+                            gr.update(value=extraction_progress.status_html(token),visible=True),
+                            gr.update(value=None,visible='hidden'))
+                def display_extraction(identifier, token=None):
+                    return gr.update(value=extract_glb(identifier, token),visible=True)
+                def finish_extract(token, image, current_seed, failed=False):
+                    extraction_progress.finish(token, failed=failed)
+                    return ('complete', gr.update(interactive=True),
+                            gr.update(interactive=available(deployment_status(),image,current_seed)),
+                            gr.update(active=False),
+                            gr.update(value=extraction_progress.status_html(token),visible=True))
+                extraction = extract_btn.click(begin_extract,[generated_asset],
+                    [phase,extract_btn,generate_btn,extraction_token,extraction_timer,extraction_status,download_btn],
+                    queue=False,api_visibility='private')
+                extraction = extraction.then(display_extraction,[generated_asset,extraction_token],download_btn,api_name='extract_glb',
+                    concurrency_limit=1,concurrency_id='supra-tex-gpu',show_progress='hidden')
+                extraction.success(finish_extract,[extraction_token,input_image,seed],
+                    [phase,extract_btn,generate_btn,extraction_timer,extraction_status],queue=False,api_visibility='private')
+                extraction.failure(lambda token,image,current_seed:finish_extract(token,image,current_seed,failed=True),
+                    [extraction_token,input_image,seed], [phase,extract_btn,generate_btn,extraction_timer,extraction_status],
+                    queue=False,api_visibility='private')
+                extraction_timer.tick(extraction_progress.status_html,[extraction_token],extraction_status,
+                    queue=False,api_visibility='private',show_progress='hidden')
             progress_timer.tick(generation_progress.status_html, [generation_token], progress_state,
                                 queue=False, api_visibility='private', show_progress='hidden')
             refresh.click(deployment_status, [], status_output, api_name='deployment_status', queue=False)