Sync with main evoneural: quality options, mesh viewer, GLB fix, TripoSR in Dockerfile

Dockerfile

@@ -12,8 +12,12 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+# TripoSR for mesh generation (model downloaded at runtime from Hugging Face)
+RUN git clone --depth 1 https://github.com/VAST-AI-Research/TripoSR.git TripoSR
+
 COPY app.py .
 COPY scripts/ ./scripts/
+COPY pages/ ./pages/
 
 # HF Spaces expose port 7860
 EXPOSE 7860

app.py

@@ -76,12 +76,49 @@ def main() -> None:
             mesh_format = st.selectbox("Mesh format", ["glb", "obj"], key="mesh_fmt")
             seed_mesh = st.number_input("Seed (optional)", value=42, min_value=0, key="mesh_seed")
         with col2:
-            use_image = st.checkbox("Use uploaded image instead of text", value=False, key="use_img")
-            uploaded = st.file_uploader("Upload image for mesh", type=["png", "jpg"], key="mesh_upload") if use_image else None
+            use_image = st.checkbox("Use image (from outputs or upload)", value=False, key="use_img")
+
+        with st.expander("Quality options (TripoSR)", expanded=True):
+            mc_resolution = st.selectbox(
+                "Mesh resolution",
+                options=[256, 512],
+                index=1,
+                format_func=lambda x: f"{x} (faster)" if x == 256 else f"{x} (higher quality)",
+                key="mesh_mc_res",
+                help="Marching cubes grid. 512 gives finer, less blocky meshes.",
+            )
+            bake_texture = st.checkbox(
+                "Bake texture atlas",
+                value=True,
+                key="mesh_bake_tex",
+                help="Produces a texture map instead of vertex colors; usually looks cleaner.",
+            )
+            smooth_mesh = st.checkbox(
+                "Smooth mesh",
+                value=True,
+                key="mesh_smooth",
+                help="Light Laplacian smoothing to reduce blockiness.",
+            )
+            output_images = sorted(Path(OUTPUTS).glob("*.png"), key=lambda p: p.stat().st_mtime, reverse=True)
+            output_images += sorted(Path(OUTPUTS).glob("*.jpg"), key=lambda p: p.stat().st_mtime, reverse=True)
+            selected_from_outputs = None
+            if use_image and output_images:
+                opt_names = [f.name for f in output_images]
+                k = "mesh_pick_output_img"
+                if k in st.session_state and st.session_state[k] not in opt_names:
+                    del st.session_state[k]
+                pick = st.selectbox("Pick from outputs (e.g. previous mesh input)", ["(upload below)"] + opt_names, key=k)
+                if pick and pick != "(upload below)":
+                    selected_from_outputs = Path(OUTPUTS) / pick
+            uploaded = st.file_uploader("Or upload image for mesh", type=["png", "jpg"], key="mesh_upload") if use_image else None
+
+        image_path_to_use = None
+        if use_image and (selected_from_outputs and selected_from_outputs.exists() or uploaded):
+            image_path_to_use = str(selected_from_outputs) if (selected_from_outputs and selected_from_outputs.exists()) else "upload"
 
         if st.button("Generate mesh", key="btn_mesh"):
-            if not prompt_mesh.strip() and not use_image:
-                st.warning("Enter a prompt or upload an image.")
+            if not image_path_to_use and not prompt_mesh.strip():
+                st.warning("Enter a prompt or choose/upload an image.")
             else:
                 with st.spinner("Running pipeline..."):
                     try:
@@ -96,27 +133,38 @@ def main() -> None:
                                 "TripoSR not found. Clone it: "
                                 "`git clone https://github.com/VAST-AI-Research/TripoSR.git TripoSR`"
                             )
-                        elif use_image and uploaded:
-                            path = os.path.join(OUTPUTS, "uploaded_mesh_input.png")
-                            with open(path, "wb") as f:
-                                f.write(uploaded.getvalue())
-                            mesh_path, elapsed, msg = generate_mesh_from_image(
-                                path,
-                                output_dir=str(OUTPUTS / "mesh_run"),
-                                mesh_format=mesh_format,
-                            )
-                            if mesh_path:
-                                st.success(f"Done in {elapsed:.1f}s. {msg}")
-                                with open(mesh_path, "rb") as f:
-                                    st.download_button("Download mesh", f, file_name=os.path.basename(mesh_path), key="dl_mesh_upload")
-                            else:
-                                st.error(msg)
+                        elif image_path_to_use:
+                            path = image_path_to_use
+                            if path == "upload" and uploaded:
+                                path = os.path.join(OUTPUTS, "uploaded_mesh_input.png")
+                                with open(path, "wb") as f:
+                                    f.write(uploaded.getvalue())
+                            if path != "upload" and os.path.isfile(path):
+                                mesh_path, elapsed, msg = generate_mesh_from_image(
+                                    path,
+                                    output_dir=str(OUTPUTS / "mesh_run"),
+                                    mesh_format=mesh_format,
+                                    mc_resolution=mc_resolution,
+                                    bake_texture=bake_texture,
+                                    smooth_mesh=smooth_mesh,
+                                )
+                                if mesh_path:
+                                    st.success(f"Done in {elapsed:.1f}s. {msg}")
+                                    with open(mesh_path, "rb") as f:
+                                        st.download_button("Download mesh", f, file_name=os.path.basename(mesh_path), key="dl_mesh_upload")
+                                else:
+                                    st.error(msg)
+                            elif path == "upload":
+                                st.warning("Upload an image first.")
                         else:
                             mesh_path, elapsed, msg = generate_mesh_from_text(
                                 prompt_mesh,
                                 output_dir=str(OUTPUTS),
                                 mesh_format=mesh_format,
                                 seed=seed_mesh,
+                                mc_resolution=mc_resolution,
+                                bake_texture=bake_texture,
+                                smooth_mesh=smooth_mesh,
                             )
                             if mesh_path:
                                 st.success(f"Done in {elapsed:.1f}s. {msg}")
@@ -127,6 +175,44 @@ def main() -> None:
                     except Exception as e:
                         st.exception(e)
 
+        # View 3D mesh (GLB): path, upload, or pick from outputs
+        with st.expander("View 3D mesh", expanded=False):
+            st.caption("Open a .glb file by path, upload, or pick from outputs. Drag to rotate, scroll to zoom.")
+            from scripts.mesh_viewer import mesh_viewer_html
+            import streamlit.components.v1 as components
+
+            viewer_glb_path: str | None = None
+            viewer_glb_bytes: bytes | None = None
+
+            path_input = st.text_input(
+                "Path to .glb file",
+                value="",
+                key="mesh_viewer_path",
+                placeholder=r"e.g. C:\Users\...\Downloads\mesh (1).glb",
+            )
+            if path_input and Path(path_input.strip()).is_file():
+                viewer_glb_path = path_input.strip()
+
+            uploaded_glb = st.file_uploader("Or upload a .glb file", type=["glb"], key="mesh_viewer_upload")
+            if uploaded_glb is not None:
+                viewer_glb_bytes = uploaded_glb.getvalue()
+
+            output_glbs = sorted(Path(OUTPUTS).rglob("*.glb"), key=lambda p: p.stat().st_mtime, reverse=True)
+            if not viewer_glb_path and not viewer_glb_bytes and output_glbs:
+                opt_names = [str(p.relative_to(OUTPUTS)) for p in output_glbs]
+                k = "mesh_viewer_pick"
+                if k in st.session_state and st.session_state[k] not in opt_names:
+                    del st.session_state[k]
+                picked = st.selectbox("Or pick from outputs", ["(none)"] + opt_names, key=k)
+                if picked and picked != "(none)":
+                    viewer_glb_path = str(OUTPUTS / picked)
+
+            if viewer_glb_path or viewer_glb_bytes:
+                html = mesh_viewer_html(glb_path=viewer_glb_path, glb_bytes=viewer_glb_bytes, height_px=480)
+                components.html(html, height=500, scrolling=False)
+            else:
+                st.info("Enter a path to a .glb file, upload one, or generate a mesh above and pick it from outputs.")
+
     with tab_skybox:
         st.subheader("Generate 2:1 equirectangular skybox")
         st.markdown(
@@ -209,7 +295,6 @@ def main() -> None:
             option_names = [f.name for f in output_files]
 
             if output_files:
-                # Keep selectbox state valid: if stored value is not in current options, clear it
                 key = "skybox_select_existing"
                 if key in st.session_state and st.session_state[key] not in option_names:
                     del st.session_state[key]

requirements.txt

@@ -19,15 +19,19 @@ safetensors>=0.4.0
 # xformers  # uncomment if you have CUDA and want lower VRAM
 
 # Mesh: TripoSR dependencies (also need TripoSR repo cloned - see README)
+# rembg needs onnxruntime; use [cpu] or [gpu] so TripoSR background removal works
 huggingface-hub>=0.20.0
-rembg>=2.0.50
+rembg[cpu]>=2.0.50
 numpy>=1.24.0
 
 # Text-to-image for mesh (same as skybox stack)
 # (already above)
 
-# TripoSR-specific (install after cloning TripoSR, or use our subprocess runner)
-# omegaconf==2.3.0
-# einops==0.7.0
-# trimesh>=4.0.0
-# xatlas==0.0.9
+# TripoSR-specific (subprocess runs TripoSR; these must be in app env)
+xatlas>=0.0.9
+trimesh>=4.0.0
+einops>=0.7.0
+omegaconf>=2.3.0
+moderngl>=5.10.0
+imageio>=2.33.0
+# torchmcubes: pip install git+https://github.com/tatsy/torchmcubes.git (needs CUDA/CMake; see TripoSR README)

scripts/hunyuan3d_runner/__init__.py

@@ -0,0 +1,2 @@
+# Runner for Hunyuan3D-2 full text-to-3D pipeline.
+# Run run_text_to_mesh.py with cwd=Hunyuan3D-2 repo root and PYTHONPATH=repo root.

scripts/hunyuan3d_runner/run_text_to_mesh.py

@@ -0,0 +1,122 @@
+"""
+Hunyuan3D-2 full pipeline: text → image (HunyuanDiT) → shape (Hunyuan3D-DiT) → texture (Hunyuan3D-Paint) → mesh.
+Designed to run with cwd = Hunyuan3D-2 repo root and PYTHONPATH = repo root so that 'hy3dgen' is importable.
+
+Usage (from evoneural, via subprocess):
+  env PYTHONPATH=/path/to/Hunyuan3D-2 python -m scripts.hunyuan3d_runner.run_text_to_mesh ...
+Or from Hunyuan3D-2 repo root:
+  PYTHONPATH=. python /path/to/evoneural/scripts/hunyuan3d_runner/run_text_to_mesh.py --prompt "a cat" --output_dir ./out
+"""
+
+import argparse
+import os
+import sys
+import time
+from pathlib import Path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Hunyuan3D-2: text or image → textured 3D mesh")
+    parser.add_argument("--prompt", type=str, default="", help="Text prompt for text-to-3D (omit if using --image)")
+    parser.add_argument("--image", type=str, default="", help="Input image path for image-to-3D (overrides --prompt)")
+    parser.add_argument("--output_dir", type=str, required=True, help="Directory to write the mesh file(s)")
+    parser.add_argument("--output_name", type=str, default="", help="Base name for output file (default: mesh or derived from prompt)")
+    parser.add_argument("--format", type=str, choices=["glb", "obj"], default="glb")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--no-texture", action="store_true", help="Skip texture stage (output untextured mesh)")
+    parser.add_argument("--model_path", type=str, default="tencent/Hunyuan3D-2")
+    parser.add_argument("--subfolder", type=str, default="", help="Subfolder for shape model (e.g. hunyuan3d-dit-v2-0)")
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--steps", type=int, default=50)
+    parser.add_argument("--guidance_scale", type=float, default=7.5)
+    parser.add_argument("--octree_resolution", type=int, default=256)
+    parser.add_argument("--num_chunks", type=int, default=200000)
+    parser.add_argument("--rembg", action="store_true", default=True, help="Remove background from image (default: True)")
+    parser.add_argument("--no-rembg", action="store_false", dest="rembg")
+    args = parser.parse_args()
+
+    try:
+        from hy3dgen.rembg import BackgroundRemover
+        from hy3dgen.shapegen import Hunyuan3DDiTFlowMatchingPipeline
+        from hy3dgen.shapegen.pipelines import export_to_trimesh
+        from hy3dgen.texgen import Hunyuan3DPaintPipeline
+    except ImportError as e:
+        print("hy3dgen not found. Run this script with cwd = Hunyuan3D-2 repo root and PYTHONPATH = repo root.", file=sys.stderr)
+        print("Example: PYTHONPATH=/path/to/Hunyuan3D-2 python run_text_to_mesh.py --prompt 'a cat' --output_dir ./out", file=sys.stderr)
+        raise SystemExit(1) from e
+
+    import torch
+    from PIL import Image
+
+    Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+
+    # Resolve input image: text → image (HunyuanDiT) or use --image
+    if args.image and os.path.isfile(args.image):
+        image = Image.open(args.image).convert("RGBA")
+    elif args.prompt.strip():
+        try:
+            from hy3dgen.text2image import HunyuanDiTPipeline
+        except ImportError:
+            print("Text-to-3D requires hy3dgen.text2image (HunyuanDiT). Install Hunyuan3D-2 with text2image support.", file=sys.stderr)
+            raise SystemExit(1)
+        t2i = HunyuanDiTPipeline("Tencent-Hunyuan/HunyuanDiT-v1.1-Diffusers-Distilled", device=args.device)
+        gen = torch.Generator(device=args.device).manual_seed(args.seed)
+        image = t2i(args.prompt, generator=gen)
+        if not isinstance(image, Image.Image):
+            image = image.images[0] if hasattr(image, "images") else image
+        image = image.convert("RGBA")
+    else:
+        print("Provide either --prompt or --image.", file=sys.stderr)
+        raise SystemExit(1)
+
+    # Optional background removal
+    if args.rembg and image.mode == "RGBA":
+        try:
+            rembg = BackgroundRemover()
+            image = rembg(image.convert("RGB"))
+            if not isinstance(image, Image.Image):
+                image = Image.fromarray(image)
+            image = image.convert("RGBA")
+        except Exception as e:
+            print(f"rembg warning: {e}", file=sys.stderr)
+
+    # Shape generation
+    load_kw = {"use_safetensors": True, "device": args.device}
+    if args.subfolder:
+        load_kw["subfolder"] = args.subfolder
+    shape_pipeline = Hunyuan3DDiTFlowMatchingPipeline.from_pretrained(args.model_path, **load_kw)
+    generator = torch.Generator(device=args.device).manual_seed(args.seed)
+    outputs = shape_pipeline(
+        image=image,
+        num_inference_steps=args.steps,
+        guidance_scale=args.guidance_scale,
+        generator=generator,
+        octree_resolution=args.octree_resolution,
+        num_chunks=args.num_chunks,
+        output_type="mesh",
+    )
+    mesh = export_to_trimesh(outputs)[0]
+
+    # Texture (optional)
+    if not args.no_texture:
+        tex_pipeline = Hunyuan3DPaintPipeline.from_pretrained(args.model_path)
+        if args.device == "cuda":
+            try:
+                tex_pipeline.to(args.device)
+            except Exception:
+                pass
+        mesh = tex_pipeline(mesh, image=image)
+
+    # Output filename
+    if args.output_name:
+        base = args.output_name
+    else:
+        base = "mesh"
+    out_path = Path(args.output_dir) / f"{base}.{args.format}"
+    mesh.export(str(out_path))
+    print(str(Path(out_path).resolve()))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/hunyuan3d_text_to_mesh.py

@@ -0,0 +1,186 @@
+"""
+Hunyuan3D-2 full text-to-3D pipeline integration.
+Finds the Hunyuan3D-2 repo (env HUNYUAN3D2_ROOT or ./Hunyuan3D-2) and invokes the runner
+with PYTHONPATH and cwd set so hy3dgen is importable. Returns (mesh_path, elapsed_sec, message).
+"""
+
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def find_hunyuan3d2_root(project_root: str | None = None) -> str | None:
+    """Locate Hunyuan3D-2 repo: HUNYUAN3D2_ROOT env, or ./Hunyuan3D-2, or ../Hunyuan3D-2."""
+    root_env = os.environ.get("HUNYUAN3D2_ROOT", "").strip()
+    if root_env and os.path.isdir(root_env) and os.path.isdir(os.path.join(root_env, "hy3dgen")):
+        return os.path.abspath(root_env)
+
+    if project_root is None:
+        project_root = str(Path(__file__).resolve().parent.parent)
+    for p in [
+        os.path.join(project_root, "Hunyuan3D-2"),
+        os.path.join(project_root, "..", "Hunyuan3D-2"),
+    ]:
+        if os.path.isdir(p) and os.path.isdir(os.path.join(p, "hy3dgen")):
+            return os.path.abspath(p)
+    return None
+
+
+def _runner_script_path() -> Path:
+    """Path to run_text_to_mesh.py (must be run with cwd=Hunyuan3D-2 so hy3dgen is found)."""
+    return Path(__file__).resolve().parent / "hunyuan3d_runner" / "run_text_to_mesh.py"
+
+
+def generate_mesh_from_text_hunyuan3d2(
+    prompt: str,
+    output_dir: str = "outputs",
+    mesh_format: str = "glb",
+    seed: int = 42,
+    with_texture: bool = True,
+    hunyuan_root: str | None = None,
+    device: str = "cuda",
+    timeout: int = 600,
+) -> tuple[str | None, float, str]:
+    """
+    Full text-to-3D via Hunyuan3D-2: text → HunyuanDiT (image) → shape → texture → mesh.
+    Returns (path_to_mesh, elapsed_sec, message). On failure returns (None, elapsed, error_message).
+    """
+    root = hunyuan_root or find_hunyuan3d2_root()
+    if not root:
+        return (
+            None,
+            0.0,
+            "Hunyuan3D-2 repo not found. Set HUNYUAN3D2_ROOT or clone into ./Hunyuan3D-2 (see README).",
+        )
+
+    script = _runner_script_path()
+    if not script.is_file():
+        return (None, 0.0, f"Runner script not found: {script}")
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    cmd = [
+        sys.executable,
+        str(script),
+        "--prompt",
+        prompt,
+        "--output_dir",
+        output_dir,
+        "--format",
+        mesh_format,
+        "--seed",
+        str(seed),
+        "--device",
+        device,
+    ]
+    if not with_texture:
+        cmd.append("--no-texture")
+    env = {**os.environ, "PYTHONPATH": root}
+
+    t0 = time.perf_counter()
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=root,
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        elapsed = time.perf_counter() - t0
+        if result.returncode != 0:
+            err = (result.stderr or result.stdout or "unknown").strip()
+            return (None, elapsed, f"Hunyuan3D-2 failed: {err[:500]}")
+        # Runner prints the absolute output path on success
+        out_line = (result.stdout or "").strip().splitlines()[-1] if result.stdout else ""
+        if out_line and os.path.isfile(out_line):
+            return (os.path.abspath(out_line), elapsed, "OK")
+        # Fallback: standard output path
+        out_path = Path(output_dir) / f"mesh.{mesh_format}"
+        if out_path.is_file():
+            return (str(out_path.resolve()), elapsed, "OK")
+        return (None, elapsed, "Runner did not produce mesh file.")
+    except subprocess.TimeoutExpired:
+        elapsed = time.perf_counter() - t0
+        return (None, elapsed, f"Hunyuan3D-2 timed out ({timeout}s)")
+    except Exception as e:
+        elapsed = time.perf_counter() - t0
+        return (None, elapsed, str(e))
+
+
+def generate_mesh_from_image_hunyuan3d2(
+    image_path: str,
+    output_dir: str = "outputs",
+    mesh_format: str = "glb",
+    seed: int = 42,
+    with_texture: bool = True,
+    hunyuan_root: str | None = None,
+    device: str = "cuda",
+    timeout: int = 600,
+) -> tuple[str | None, float, str]:
+    """
+    Image-to-3D via Hunyuan3D-2: image → shape → texture → mesh.
+    Returns (path_to_mesh, elapsed_sec, message).
+    """
+    root = hunyuan_root or find_hunyuan3d2_root()
+    if not root:
+        return (
+            None,
+            0.0,
+            "Hunyuan3D-2 repo not found. Set HUNYUAN3D2_ROOT or clone into ./Hunyuan3D-2 (see README).",
+        )
+
+    script = _runner_script_path()
+    if not script.is_file():
+        return (None, 0.0, f"Runner script not found: {script}")
+
+    if not os.path.isfile(image_path):
+        return (None, 0.0, f"Image not found: {image_path}")
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    cmd = [
+        sys.executable,
+        str(script),
+        "--image",
+        os.path.abspath(image_path),
+        "--output_dir",
+        output_dir,
+        "--format",
+        mesh_format,
+        "--seed",
+        str(seed),
+        "--device",
+        device,
+    ]
+    if not with_texture:
+        cmd.append("--no-texture")
+    env = {**os.environ, "PYTHONPATH": root}
+
+    t0 = time.perf_counter()
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=root,
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        elapsed = time.perf_counter() - t0
+        if result.returncode != 0:
+            err = (result.stderr or result.stdout or "unknown").strip()
+            return (None, elapsed, f"Hunyuan3D-2 failed: {err[:500]}")
+        out_line = (result.stdout or "").strip().splitlines()[-1] if result.stdout else ""
+        if out_line and os.path.isfile(out_line):
+            return (os.path.abspath(out_line), elapsed, "OK")
+        out_path = Path(output_dir) / f"mesh.{mesh_format}"
+        if out_path.is_file():
+            return (str(out_path.resolve()), elapsed, "OK")
+        return (None, elapsed, "Runner did not produce mesh file.")
+    except subprocess.TimeoutExpired:
+        elapsed = time.perf_counter() - t0
+        return (None, elapsed, f"Hunyuan3D-2 timed out ({timeout}s)")
+    except Exception as e:
+        elapsed = time.perf_counter() - t0
+        return (None, elapsed, str(e))

scripts/mesh_generator.py

@@ -1,7 +1,7 @@
 """
-Mesh generator: image → 3D mesh via TripoSR (local).
-Expects TripoSR repo cloned at project_root/TripoSR. Uses subprocess to run run.py.
-For text→mesh: first generate image with text_to_image(), then call this.
+Mesh generator: text/image → 3D mesh.
+- Preferred: Hunyuan3D-2 full pipeline (text → HunyuanDiT → shape → texture). Set HUNYUAN3D2_ROOT or clone ./Hunyuan3D-2.
+- Fallback: TripoSR (image→mesh). Expects TripoSR repo at project_root/TripoSR. Text→mesh uses SD for text→image then TripoSR.
 """
 
 import os
@@ -26,18 +26,90 @@ def find_triposr_root(project_root: str | None = None) -> str | None:
     return None
 
 
+def _obj_texture_to_glb(obj_path: str, texture_path: str, glb_path: str) -> None:
+    """
+    Convert OBJ + texture.png to a valid GLB with embedded texture.
+    TripoSR's xatlas.export writes OBJ format regardless of extension; use this to produce real GLB.
+    """
+    import trimesh
+    from PIL import Image
+    mesh = trimesh.load(obj_path, file_type="obj", process=False)
+    if not isinstance(mesh, trimesh.Trimesh):
+        mesh = mesh.dump(concatenate=True) if hasattr(mesh, "dump") else None
+    if mesh is None:
+        return
+    # Ensure texture image is set (xatlas may not write MTL)
+    if hasattr(mesh, "visual") and mesh.visual is not None and getattr(mesh.visual, "uv", None) is not None:
+        try:
+            img = Image.open(texture_path)
+            from trimesh.visual import TextureVisuals
+            mesh.visual = TextureVisuals(uv=mesh.visual.uv, image=img)
+        except Exception:
+            pass
+    mesh.export(glb_path)
+
+
+def _is_obj_content(path: str) -> bool:
+    """Return True if file content looks like OBJ (TripoSR xatlas writes OBJ even when path is .glb)."""
+    try:
+        with open(path, "rb") as f:
+            return f.read(2).strip() == b"v"
+    except Exception:
+        return False
+
+
+def _smooth_mesh_file(mesh_path: str, iterations: int = 3, lamb: float = 0.5) -> None:
+    """Apply light Laplacian smoothing to a mesh file in-place. Preserves UVs."""
+    import trimesh
+    loaded = trimesh.load(mesh_path, force="mesh", process=False)
+    if isinstance(loaded, trimesh.Trimesh):
+        mesh = loaded
+    elif hasattr(loaded, "dump"):
+        mesh = loaded.dump(concatenate=True)
+    else:
+        return
+    if mesh is None:
+        return
+    try:
+        trimesh.smoothing.filter_laplacian(mesh, lamb=lamb, iterations=iterations)
+    except Exception:
+        return
+    mesh.export(mesh_path)
+
+
 def generate_mesh_from_image(
     image_path: str,
     output_dir: str = "outputs",
     mesh_format: str = "glb",
     triposr_root: str | None = None,
     device: str = "cuda:0",
+    use_hunyuan3d2: bool | None = None,
+    mc_resolution: int = 512,
+    bake_texture: bool = True,
+    texture_resolution: int = 2048,
+    smooth_mesh: bool = True,
 ) -> tuple[str | None, float, str]:
     """
-    Run TripoSR on an image. Returns (path_to_mesh, inference_time_sec, message).
-    If TripoSR is not found, returns (None, 0, error_message).
+    Image → 3D mesh. Uses Hunyuan3D-2 when available (use_hunyuan3d2=True or repo found), else TripoSR.
+    mc_resolution: marching cubes grid (256=faster, 512=higher quality). bake_texture: use texture atlas.
+    smooth_mesh: apply light Laplacian smoothing. Returns (path_to_mesh, inference_time_sec, message).
     """
     project_root = str(Path(__file__).resolve().parent.parent)
+    hunyuan_root = find_hunyuan3d2_root(project_root)
+    if use_hunyuan3d2 is True or (use_hunyuan3d2 is None and hunyuan_root is not None):
+        if hunyuan_root:
+            from scripts.hunyuan3d_text_to_mesh import generate_mesh_from_image_hunyuan3d2
+            return generate_mesh_from_image_hunyuan3d2(
+                image_path,
+                output_dir=output_dir,
+                mesh_format=mesh_format,
+                seed=42,
+                with_texture=True,
+                hunyuan_root=hunyuan_root,
+            )
+        if use_hunyuan3d2 is True:
+            return (None, 0.0, "Hunyuan3D-2 repo not found. Set HUNYUAN3D2_ROOT or clone ./Hunyuan3D-2 (see README).")
+
     triposr_root = triposr_root or find_triposr_root(project_root)
     if not triposr_root:
         return (
@@ -47,7 +119,9 @@ def generate_mesh_from_image(
         )
 
     Path(output_dir).mkdir(parents=True, exist_ok=True)
-    # TripoSR writes to output_dir/0/mesh.obj (or mesh.glb)
+    # When baking texture, xatlas.export() always writes OBJ format (ignores .glb extension).
+    # Ask for OBJ when bake_texture + glb, then we convert OBJ+texture to real GLB.
+    triposr_format = "obj" if (bake_texture and mesh_format == "glb") else mesh_format
     run_py = os.path.join(triposr_root, "run.py")
     cmd = [
         sys.executable,
@@ -56,19 +130,28 @@ def generate_mesh_from_image(
         "--output-dir",
         output_dir,
         "--model-save-format",
-        mesh_format,
+        triposr_format,
         "--device",
         device,
+        "--mc-resolution",
+        str(mc_resolution),
     ]
+    if bake_texture:
+        cmd += ["--bake-texture", "--texture-resolution", str(texture_resolution)]
+    # Use only the current env (venv) so torch and torchvision match; avoids
+    # "operator torchvision::nms does not exist" when user site-packages mixed in.
+    env = os.environ.copy()
+    env["PYTHONNOUSERSITE"] = "1"
 
     t0 = time.perf_counter()
     try:
         result = subprocess.run(
             cmd,
             cwd=triposr_root,
+            env=env,
             capture_output=True,
             text=True,
-            timeout=120,
+            timeout=600,
         )
         t1 = time.perf_counter()
         if result.returncode != 0:
@@ -78,44 +161,101 @@ def generate_mesh_from_image(
                 f"TripoSR failed: {result.stderr or result.stdout or 'unknown'}",
             )
         # Output is output_dir/0/mesh.glb or mesh.obj
-        mesh_path = os.path.join(output_dir, "0", f"mesh.{mesh_format}")
+        out_subdir = os.path.join(output_dir, "0")
+        mesh_path = os.path.join(out_subdir, f"mesh.{triposr_format}")
         if not os.path.isfile(mesh_path):
             return (None, t1 - t0, f"TripoSR did not produce {mesh_path}")
+        # If we asked for GLB but TripoSR wrote OBJ (bake_texture), convert to real GLB
+        if bake_texture and mesh_format == "glb":
+            texture_path = os.path.join(out_subdir, "texture.png")
+            glb_path = os.path.join(out_subdir, "mesh.glb")
+            try:
+                _obj_texture_to_glb(mesh_path, texture_path, glb_path)
+                mesh_path = glb_path
+            except Exception:
+                pass  # keep mesh.obj path if conversion fails
+        # If existing file is misnamed (OBJ content in .glb), repair it
+        elif mesh_format == "glb" and _is_obj_content(mesh_path):
+            texture_path = os.path.join(out_subdir, "texture.png")
+            try:
+                _obj_texture_to_glb(mesh_path, texture_path, mesh_path)
+            except Exception:
+                pass
+        if smooth_mesh:
+            try:
+                _smooth_mesh_file(mesh_path, iterations=3, lamb=0.5)
+            except Exception:
+                pass
         return (os.path.abspath(mesh_path), t1 - t0, "OK")
     except subprocess.TimeoutExpired:
         t1 = time.perf_counter()
-        return (None, t1 - t0, "TripoSR timed out (120s)")
+        return (None, t1 - t0, "TripoSR timed out (10 min). Try lower resolution (256) or disable bake texture.")
     except Exception as e:
         t1 = time.perf_counter()
         return (None, t1 - t0, str(e))
 
 
+def find_hunyuan3d2_root(project_root: str | None = None) -> str | None:
+    """Locate Hunyuan3D-2 repo. Delegates to hunyuan3d_text_to_mesh."""
+    try:
+        from scripts.hunyuan3d_text_to_mesh import find_hunyuan3d2_root as _find
+        return _find(project_root)
+    except Exception:
+        return None
+
+
 def generate_mesh_from_text(
     prompt: str,
     output_dir: str = "outputs",
     mesh_format: str = "glb",
     seed: int | None = None,
+    use_hunyuan3d2: bool | None = None,
+    mc_resolution: int = 512,
+    bake_texture: bool = True,
+    texture_resolution: int = 2048,
+    smooth_mesh: bool = True,
 ) -> tuple[str | None, float, str]:
     """
-    Text → image (SD) → mesh (TripoSR). Returns (path_to_mesh, total_time_sec, message).
+    Text → 3D mesh. Uses Hunyuan3D-2 full pipeline when available (use_hunyuan3d2=True or repo found),
+    else TripoSR (SD for text→image then TripoSR). Returns (path_to_mesh, total_time_sec, message).
     """
-    # Import here so script can run from any cwd
     _root = str(Path(__file__).resolve().parent.parent)
     if _root not in sys.path:
         sys.path.insert(0, _root)
-    from scripts.text_to_image import text_to_image
-
     Path(output_dir).mkdir(parents=True, exist_ok=True)
+    seed = seed if seed is not None else 42
+
+    # Prefer Hunyuan3D-2 when requested or when it's the only backend available
+    hunyuan_root = find_hunyuan3d2_root(_root)
+    if use_hunyuan3d2 is True or (use_hunyuan3d2 is None and hunyuan_root is not None):
+        if hunyuan_root:
+            from scripts.hunyuan3d_text_to_mesh import generate_mesh_from_text_hunyuan3d2
+            return generate_mesh_from_text_hunyuan3d2(
+                prompt,
+                output_dir=output_dir,
+                mesh_format=mesh_format,
+                seed=seed,
+                with_texture=True,
+                hunyuan_root=hunyuan_root,
+            )
+        if use_hunyuan3d2 is True:
+            return (None, 0.0, "Hunyuan3D-2 repo not found. Set HUNYUAN3D2_ROOT or clone ./Hunyuan3D-2 (see README).")
+
+    # TripoSR path: text → image (SD) → mesh
+    from scripts.text_to_image import text_to_image
     t0 = time.perf_counter()
     try:
         image_path, _ = text_to_image(prompt, output_dir=output_dir, seed=seed)
     except Exception as e:
         return (None, 0.0, f"Text-to-image failed: {e}")
-
     mesh_path, mesh_time, msg = generate_mesh_from_image(
         image_path,
         output_dir=os.path.join(output_dir, "mesh_run"),
         mesh_format=mesh_format,
+        mc_resolution=mc_resolution,
+        bake_texture=bake_texture,
+        texture_resolution=texture_resolution,
+        smooth_mesh=smooth_mesh,
     )
     total_time = time.perf_counter() - t0
     if mesh_path:

scripts/mesh_viewer.py

@@ -0,0 +1,69 @@
+"""
+3D mesh viewer for GLB/glTF. Returns HTML for use with st.components.v1.html().
+Uses Google's <model-viewer> web component with base64-embedded GLB.
+"""
+
+import base64
+from pathlib import Path
+
+# Embedding very large GLBs can make the page slow; warn above this size (bytes)
+MAX_EMBED_BYTES = 15 * 1024 * 1024  # 15 MB
+
+
+def mesh_viewer_html(glb_path: str | Path | None = None, glb_bytes: bytes | None = None, height_px: int = 480) -> str:
+    """
+    Build HTML for an interactive 3D mesh viewer (model-viewer).
+    Provide either glb_path (file path) or glb_bytes (raw GLB). Prefers path if both given.
+    Returns HTML string. If no valid input or file too large, returns a short error HTML.
+    """
+    data_uri: str | None = None
+    if glb_path:
+        p = Path(glb_path)
+        if p.is_file() and p.suffix.lower() in (".glb", ".gltf"):
+            try:
+                raw = p.read_bytes()
+            except Exception:
+                raw = b""
+        else:
+            raw = b""
+    elif glb_bytes:
+        raw = glb_bytes
+    else:
+        raw = b""
+
+    if not raw or len(raw) < 4:
+        return (
+            "<p style='padding:1em;color:#888;'>No GLB loaded. Upload a .glb file or choose one from outputs.</p>"
+        )
+
+    if len(raw) > MAX_EMBED_BYTES:
+        return (
+            f"<p style='padding:1em;color:#c66;'>Mesh is too large to embed in viewer ({len(raw) / 1024 / 1024:.1f} MB). "
+            "Use a local viewer or a smaller mesh.</p>"
+        )
+
+    b64 = base64.b64encode(raw).decode("utf-8")
+    data_uri = f"data:model/gltf-binary;base64,{b64}"
+
+    # model-viewer from unpkg; use module script
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <script type="module" src="https://unpkg.com/@google/model-viewer@3.4.0/dist/model-viewer.min.js"></script>
+  <style>
+    model-viewer {{ width: 100%; height: {height_px}px; background: #1a1a1a; }}
+  </style>
+</head>
+<body>
+  <model-viewer
+    src="{data_uri}"
+    alt="3D mesh"
+    camera-controls
+    auto-rotate
+    shadow-intensity="0.6"
+    exposure="0.8"
+    style="width:100%; height:{height_px}px;"
+  ></model-viewer>
+</body>
+</html>"""

scripts/panorama_viewer.py

@@ -1,6 +1,6 @@
 """
 360° panorama viewer for equirectangular (2:1) skybox images.
-Returns HTML string for use with st.components.v1.html().
+Returns HTML for use with st.components.v1.html().
 Resizes image to keep data URL small so it loads reliably in iframes.
 Fetches Pannellum script server-side and inlines it so the client does not load from CDN (avoids CSP/network block).
 """