notso-glb 0.1.0__py3-none-any.whl

notso_glb/cleaners/mesh.py

@@ -0,0 +1,183 @@
+"""Mesh cleanup and decimation functions."""
+
+import bpy
+from bpy.types import Modifier, Object
+
+from notso_glb.utils import get_mesh_data, get_view_layer
+from notso_glb.utils.constants import BLOAT_THRESHOLDS
+from notso_glb.utils.logging import log_warn
+
+
+def cleanup_mesh_bmesh(obj: Object) -> dict[str, int] | None:
+    """
+    Clean up mesh using bmesh operations:
+    - Remove duplicate vertices (doubles)
+    - Dissolve degenerate geometry (zero-area faces, zero-length edges)
+    - Remove loose vertices
+
+    Returns dict with cleanup stats or None if failed.
+    """
+    import bmesh
+
+    mesh = get_mesh_data(obj)
+    original_verts = len(mesh.vertices)
+    original_faces = len(mesh.polygons)
+
+    bm = bmesh.new()
+    bm.from_mesh(mesh)
+
+    stats: dict[str, int] = {
+        "doubles_merged": 0,
+        "degenerate_dissolved": 0,
+        "loose_removed": 0,
+    }
+
+    # 1. Remove doubles (merge vertices within threshold)
+    merge_dist = 0.0001  # 0.1mm threshold
+    verts_before_doubles = len(bm.verts)
+    bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=merge_dist)
+    stats["doubles_merged"] = verts_before_doubles - len(bm.verts)
+
+    # 2. Dissolve degenerate geometry
+    degenerate_faces = [f for f in bm.faces if f.calc_area() < 1e-8]
+    if degenerate_faces:
+        bmesh.ops.delete(bm, geom=degenerate_faces, context="FACES")
+        stats["degenerate_dissolved"] += len(degenerate_faces)
+
+    degenerate_edges = [e for e in bm.edges if e.calc_length() < 1e-8]
+    if degenerate_edges:
+        bmesh.ops.delete(bm, geom=degenerate_edges, context="EDGES")
+        stats["degenerate_dissolved"] += len(degenerate_edges)
+
+    # 3. Remove loose vertices (not connected to any face)
+    loose_verts = [v for v in bm.verts if not v.link_faces]
+    if loose_verts:
+        bmesh.ops.delete(bm, geom=loose_verts, context="VERTS")
+        stats["loose_removed"] = len(loose_verts)
+
+    # Write back to mesh
+    bm.to_mesh(mesh)
+    bm.free()
+
+    mesh.update()
+
+    new_verts = len(mesh.vertices)
+    new_faces = len(mesh.polygons)
+
+    stats["verts_before"] = original_verts
+    stats["verts_after"] = new_verts
+    stats["faces_before"] = original_faces
+    stats["faces_after"] = new_faces
+
+    return stats
+
+
+def decimate_mesh(obj: Object, target_verts: int) -> tuple[int, int] | None:
+    """
+    Apply decimation to reduce mesh to approximately target vertex count.
+
+    Returns (original_verts, new_verts) or None if failed.
+    """
+    mesh = get_mesh_data(obj)
+    original_verts = len(mesh.vertices)
+    if original_verts <= target_verts:
+        return None
+
+    ratio: float = target_verts / original_verts
+
+    mod: Modifier = obj.modifiers.new(name="AutoDecimate", type="DECIMATE")
+    mod.decimate_type = "COLLAPSE"  # ty:ignore[unresolved-attribute] # pyright: ignore[reportAttributeAccessIssue]
+    mod.ratio = ratio  # ty:ignore[unresolved-attribute] # pyright: ignore[reportAttributeAccessIssue]
+    mod.use_collapse_triangulate = True  # ty:ignore[unresolved-attribute] # pyright: ignore[reportAttributeAccessIssue]
+
+    view_layer = get_view_layer()
+    view_layer.objects.active = obj
+    try:
+        bpy.ops.object.modifier_apply(modifier=mod.name)
+        new_verts = len(mesh.vertices)
+        return (original_verts, new_verts)
+    except Exception as e:  # pragma: no cover - defensive
+        obj.modifiers.remove(mod)
+        log_warn(f"Failed to decimate {obj.name}: {e}")
+        return None
+
+
+def auto_fix_bloat(
+    warnings: list[dict[str, object]],
+) -> dict[str, list[dict[str, object]]]:
+    """
+    Automatically fix bloated meshes using bmesh cleanup + decimation.
+
+    Pipeline:
+    1. Run bmesh cleanup on ALL meshes (doubles, degenerate, loose)
+    2. Decimate non-skinned props still flagged as BLOATED_PROP
+
+    Returns dict with cleanup_stats and decimation_fixes.
+    """
+    results: dict[str, list[dict[str, object]]] = {
+        "cleanup": [],
+        "decimation": [],
+    }
+
+    # Phase 1: BMesh cleanup on ALL meshes
+    for obj in bpy.data.objects:
+        if obj.type != "MESH":
+            continue
+
+        mesh = get_mesh_data(obj)
+        verts_before = len(mesh.vertices)
+        if verts_before < 10:
+            continue
+
+        try:
+            stats = cleanup_mesh_bmesh(obj)
+            if stats and (
+                stats["doubles_merged"] > 0
+                or stats["degenerate_dissolved"] > 0
+                or stats["loose_removed"] > 0
+            ):
+                results["cleanup"].append({
+                    "object": obj.name,
+                    "doubles": stats["doubles_merged"],
+                    "degenerate": stats["degenerate_dissolved"],
+                    "loose": stats["loose_removed"],
+                    "verts_saved": stats["verts_before"] - stats["verts_after"],
+                })
+        except Exception as e:
+            log_warn(f"Cleanup failed for {obj.name}: {e}")
+
+    # Phase 2: Decimate bloated props
+    bloated_objects = [
+        str(w["object"])
+        for w in warnings
+        if w["issue"] == "BLOATED_PROP" and w["severity"] == "CRITICAL"
+    ]
+
+    for obj_name in bloated_objects:
+        obj = bpy.data.objects.get(obj_name)
+        if not obj or obj.type != "MESH":
+            continue
+
+        is_skinned = any(mod.type == "ARMATURE" for mod in obj.modifiers)
+        if is_skinned:
+            continue
+
+        mesh = get_mesh_data(obj)
+        current_verts = len(mesh.vertices)
+        if current_verts <= BLOAT_THRESHOLDS["prop_critical"]:
+            continue
+
+        target = int(BLOAT_THRESHOLDS["prop_critical"] * 0.8)
+
+        result = decimate_mesh(obj, target)
+        if result:
+            orig, new = result
+            reduction = ((orig - new) / orig) * 100
+            results["decimation"].append({
+                "object": obj_name,
+                "original": orig,
+                "new": new,
+                "reduction": reduction,
+            })
+
+    return results

notso_glb/cleaners/textures.py

@@ -0,0 +1,116 @@
+"""Texture resizing functions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import bpy
+
+from notso_glb.utils.logging import bright_cyan
+from notso_glb.utils.logging import dim
+from notso_glb.utils.logging import log_detail
+from notso_glb.utils.logging import log_warn
+from notso_glb.utils.logging import magenta
+
+if TYPE_CHECKING:
+    from bpy.types import Image
+
+# Images to skip during resize
+_SKIP_IMAGES = frozenset(["Render Result", "Viewer Node"])
+
+
+def _nearest_pot(n: int) -> int:
+    """Round to nearest power of two."""
+    if n <= 1:
+        return 1
+    bl = (n - 1).bit_length()
+    lower = 1 << (bl - 1)
+    upper = 1 << bl
+    return lower if (n - lower) < (upper - n) else upper
+
+
+def _is_power_of_two(n: int) -> bool:
+    """Check if n is a power of two."""
+    return n > 0 and (n & (n - 1)) == 0
+
+
+def _should_skip_image(img: Image, max_size: int, force_pot: bool) -> bool:
+    """Determine if image should be skipped."""
+    if img.name in _SKIP_IMAGES:
+        return True
+    w, h = img.size[0], img.size[1]
+    if w <= max_size and h <= max_size:
+        if not force_pot:
+            return True
+        if _is_power_of_two(w) and _is_power_of_two(h):
+            return True
+    return False
+
+
+def _calc_scaled_size(w: int, h: int, max_size: int) -> tuple[int, int]:
+    """Calculate new size maintaining aspect ratio."""
+    if w > h:
+        new_w = min(max_size, w)
+        new_h = int(h * (new_w / w))
+    else:
+        new_h = min(max_size, h)
+        new_w = int(w * (new_h / h))
+    return new_w, new_h
+
+
+def _adjust_to_pot(w: int, h: int, max_size: int) -> tuple[int, int]:
+    """Adjust dimensions to power-of-two, clamped to max_size."""
+    w = _nearest_pot(w)
+    h = _nearest_pot(h)
+    while w > max_size:
+        w //= 2
+    while h > max_size:
+        h //= 2
+    return w, h
+
+
+def _adjust_to_even(w: int, h: int) -> tuple[int, int]:
+    """Adjust dimensions to even numbers."""
+    if w % 2 != 0:
+        w += 1
+    if h % 2 != 0:
+        h += 1
+    return w, h
+
+
+def resize_textures(max_size: int = 1024, force_pot: bool = False) -> int:
+    """
+    Resize all textures larger than max_size.
+
+    Args:
+        max_size: Maximum dimension (default 1024)
+        force_pot: Force power-of-two dimensions (better GPU compatibility)
+    """
+    resized = 0
+
+    for img in bpy.data.images:
+        if _should_skip_image(img, max_size, force_pot):
+            continue
+
+        w, h = img.size[0], img.size[1]
+        new_w, new_h = _calc_scaled_size(w, h, max_size)
+
+        if force_pot:
+            new_w, new_h = _adjust_to_pot(new_w, new_h, max_size)
+        else:
+            new_w, new_h = _adjust_to_even(new_w, new_h)
+
+        if new_w == w and new_h == h:
+            continue
+
+        try:
+            img.scale(new_w, new_h)
+            resized += 1
+            pot_note = f" {magenta('(POT)')}" if force_pot else ""
+            log_detail(
+                f"{img.name}: {dim(f'{w}x{h}')} -> {bright_cyan(f'{new_w}x{new_h}')}{pot_note}"
+            )
+        except Exception as e:
+            log_warn(f"Failed to resize {img.name}: {e}")
+
+    return resized

notso_glb/cleaners/uv_maps.py

@@ -0,0 +1,29 @@
+"""UV map cleanup functions."""
+
+from typing import cast
+
+import bpy
+
+from notso_glb.utils import get_mesh_data
+
+
+def remove_unused_uv_maps(warnings: list[dict[str, object]]) -> int:
+    """Remove unused UV maps detected by analyze_unused_uv_maps."""
+    removed = 0
+
+    for warn in warnings:
+        mesh_name = cast(str, warn["mesh"])
+        obj = bpy.data.objects.get(mesh_name)
+        if not obj or obj.type != "MESH":
+            continue
+
+        mesh = get_mesh_data(obj)
+        uv_names = cast(list[str], warn["unused_uvs"])
+        for uv_name in uv_names:
+            uv_layer = mesh.uv_layers.get(uv_name)
+            if uv_layer:
+                mesh.uv_layers.remove(uv_layer)
+                removed += 1
+                print(f"    Removed unused UV '{uv_name}' from {obj.name}")
+
+    return removed

notso_glb/cleaners/vertex_groups.py

@@ -0,0 +1,34 @@
+"""Vertex group cleanup functions."""
+
+import bpy
+
+from notso_glb.utils import get_mesh_data
+
+
+def clean_vertex_groups() -> int:
+    """Remove vertex groups with no weights (empty bone references)."""
+    total_removed = 0
+
+    for obj in bpy.data.objects:
+        if obj.type != "MESH" or len(obj.vertex_groups) == 0:
+            continue
+
+        mesh = get_mesh_data(obj)
+        used_groups: set[int] = set()
+
+        for v in mesh.vertices:
+            for g in v.groups:
+                if g.weight > 0.0001:
+                    used_groups.add(g.group)
+
+        unused_names = [
+            vg.name for i, vg in enumerate(obj.vertex_groups) if i not in used_groups
+        ]
+
+        for name in unused_names:
+            vg = obj.vertex_groups.get(name)
+            if vg:
+                obj.vertex_groups.remove(vg)
+                total_removed += 1
+
+    return total_removed

notso_glb/cli.py

@@ -0,0 +1,330 @@
+"""Command-line interface for GLB export optimizer."""
+
+import os
+import sys
+from enum import Enum
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+try:
+    __version__ = version("notso-glb")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+from notso_glb.utils.constants import DEFAULT_CONFIG
+from notso_glb.utils.gltfpack import find_gltfpack
+
+app = typer.Typer(
+    name="notso-glb",
+    help="Optimize GLB/glTF/blend files for web delivery",
+    add_completion=False,
+    rich_markup_mode="rich",
+    suggest_commands=True,
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        print(f"notso-glb {__version__}")
+        raise typer.Exit()
+
+
+class ExportFormat(Enum):
+    """Output format for glTF export."""
+
+    glb = "glb"
+    gltf = "gltf"
+    gltf_embedded = "gltf-embedded"
+
+
+@app.command()
+def optimize(
+    input_path: Annotated[
+        Path,
+        typer.Argument(
+            help="Input file ([bold green].blend[/], [bold green].glb[/], or [bold green].gltf[/])",
+            metavar="FILE",
+        ),
+    ],
+    output: Annotated[
+        Path | None,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output path (default: [italic]input_optimized.\\[glb|gltf][/])",
+            rich_help_panel="Core Options",
+        ),
+    ] = DEFAULT_CONFIG["output_path"],
+    export_format: Annotated[
+        ExportFormat,
+        typer.Option(
+            "--format",
+            "-f",
+            help="Output format",
+            rich_help_panel="Core Options",
+        ),
+    ] = ExportFormat.glb,
+    use_draco: Annotated[
+        bool,
+        typer.Option(
+            "--draco/--no-draco",
+            help="Enable/Disable Draco compression",
+            rich_help_panel="Compression & Textures",
+        ),
+    ] = DEFAULT_CONFIG["use_draco"],
+    use_webp: Annotated[
+        bool,
+        typer.Option(
+            "--webp/--no-webp",
+            help="Enable/Disable WebP textures",
+            rich_help_panel="Compression & Textures",
+        ),
+    ] = DEFAULT_CONFIG["use_webp"],
+    max_texture_size: Annotated[
+        int,
+        typer.Option(
+            help="Max texture size (0=no resize)",
+            rich_help_panel="Compression & Textures",
+            metavar="PIXELS",
+        ),
+    ] = DEFAULT_CONFIG["max_texture_size"],
+    force_pot: Annotated[
+        bool,
+        typer.Option(
+            "--force-pot/",
+            help="Force power-of-two texture dimensions (better GPU compatibility)",
+            rich_help_panel="Compression & Textures",
+        ),
+    ] = DEFAULT_CONFIG["force_pot_textures"],
+    analyze_animations: Annotated[
+        bool,
+        typer.Option(
+            "--analyze-animations/--skip-animation-analysis",
+            help="Analyze bones for static/animated properties",
+            rich_help_panel="Analysis & Optimization",
+        ),
+    ] = DEFAULT_CONFIG["analyze_animations"],
+    check_bloat: Annotated[
+        bool,
+        typer.Option(
+            "--check-bloat/--skip-bloat-check",
+            help="Analyze meshes for unreasonable complexity",
+            rich_help_panel="Analysis & Optimization",
+        ),
+    ] = DEFAULT_CONFIG["check_bloat"],
+    autofix: Annotated[
+        bool,
+        typer.Option(
+            "--autofix/--stable",
+            help="Auto-decimate bloated props, remove unused UVs",
+            rich_help_panel="[bold red][EXPERIMENTAL][/]",
+        ),
+    ] = DEFAULT_CONFIG["experimental_autofix"],
+    use_gltfpack: Annotated[
+        bool,
+        typer.Option(
+            "--gltfpack/--no-gltfpack",
+            help="Post-process with gltfpack for extra compression (WASM fallback if native unavailable)",
+            rich_help_panel="Compression & Textures",
+        ),
+    ] = True,
+    quiet: Annotated[
+        bool,
+        typer.Option(
+            "--quiet/--verbose",
+            "-q/-v",
+            help="Suppress Blender's verbose output (show only warnings/errors)",
+            rich_help_panel="Output",
+        ),
+    ] = DEFAULT_CONFIG["quiet"],
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-V",
+            callback=version_callback,
+            is_eager=True,
+            help="Show the version and exit.",
+        ),
+    ] = None,
+) -> None:
+    """
+    Optimize and export 3D models for the web.
+    """
+    # Verify input existence before expensive imports
+    abs_input_path = os.path.abspath(input_path)
+    if not os.path.isfile(abs_input_path):
+        console.print(f"[bold red][ERROR][/] File not found: {abs_input_path}")
+        raise typer.Exit(code=1)
+
+    ext = os.path.splitext(abs_input_path)[1].lower()
+
+    # Lazy import to keep CLI snappy and avoid bpy issues in help
+    from notso_glb.exporters import optimize_and_export
+
+    # Determine if we need to import
+    # GLB/glTF files: pass to optimize_and_export for import with timing
+    # .blend files: already loaded if running via `blender --python`
+    input_for_import: str | None = None
+    if ext in (".glb", ".gltf"):
+        input_for_import = abs_input_path
+    elif ext != ".blend":
+        console.print(f"[bold red][ERROR][/] Unsupported format: {ext}")
+        console.print("        Supported: .blend, .glb, .gltf")
+        raise typer.Exit(code=1)
+
+    # Map CLI format to Blender format
+    format_map = {
+        "glb": "GLB",
+        "gltf": "GLTF_SEPARATE",
+        "gltf-embedded": "GLTF_EMBEDDED",
+    }
+    blender_export_format = format_map.get(export_format.value, "GLB")
+    out_ext = ".gltf" if export_format.value.startswith("gltf") else ".glb"
+
+    # Determine output path
+    final_output_path: Path
+    if output is None:
+        base = os.path.splitext(abs_input_path)[0]
+        final_output_path = Path(f"{base}_optimized{out_ext}")
+    else:
+        final_output_path = output.resolve()
+
+    # Run optimization
+    result = optimize_and_export(
+        output_path=final_output_path,
+        export_format=blender_export_format,
+        use_draco=use_draco,
+        use_webp=use_webp,
+        max_texture_size=max_texture_size,
+        force_pot_textures=force_pot,
+        analyze_animations=analyze_animations,
+        check_bloat=check_bloat,
+        experimental_autofix=autofix,
+        quiet=quiet,
+        input_path=input_for_import,
+    )
+
+    if not result:
+        raise typer.Exit(code=1)
+
+    # Post-process with gltfpack if enabled
+    if use_gltfpack:
+        from notso_glb.utils.gltfpack import run_gltfpack
+        from notso_glb.utils.logging import format_bytes
+        from notso_glb.wasm import is_available as wasm_available
+
+        native_available = find_gltfpack() is not None
+        wasm_ok = wasm_available()
+
+        if not native_available and not wasm_ok:
+            console.print(
+                "[bold yellow][WARN][/] gltfpack not found and WASM unavailable, skipping"
+            )
+        else:
+            backend = "native" if native_available else "WASM"
+            console.print(f"\n[bold cyan]Running gltfpack ({backend})...[/]")
+            original_size = Path(result).stat().st_size
+
+            success, packed_path, msg = run_gltfpack(
+                Path(result),
+                output_path=Path(result),  # Overwrite original
+                texture_compress=True,
+                mesh_compress=True,
+            )
+
+            if success:
+                new_size = packed_path.stat().st_size
+                if original_size == 0:
+                    reduction = 0.0
+                else:
+                    reduction = ((original_size - new_size) / original_size) * 100
+                console.print(
+                    f"  [green]gltfpack:[/] {format_bytes(original_size)} -> "
+                    f"{format_bytes(new_size)} ([bold green]-{reduction:.0f}%[/])"
+                )
+            else:
+                console.print(f"  [bold red][ERROR][/] {msg}")
+
+
+def main() -> None:
+    """Entry point - handles both CLI and Blender UI execution."""
+    # Detect execution mode:
+    # 1. Direct: ./script.py input.glb
+    # 2. Blender: blender --python script.py -- input.glb
+
+    args = sys.argv[1:]
+
+    # Check for '--' separator used in Blender execution
+    if "--" in sys.argv:
+        idx = sys.argv.index("--")
+        args = sys.argv[idx + 1 :]
+    elif len(sys.argv) > 0:
+        # Check if we are inside Blender (executable check)
+        # If running as `blender script.py`, argv[0] is blender.
+        executable = os.path.basename(sys.argv[0]).lower()
+        if "blender" in executable:
+            # Running in Blender without '--' -> UI mode, run with defaults?
+            # Or just show help?
+            # Original code ran with defaults if no args.
+            # Let's try to run the command with empty args if that was the intent,
+            # or just pass empty list which might trigger help if arg is required.
+            pass
+
+        # Typer expects the program name as the first "arg" in sys.argv usually,
+        # but when calling app() directly with list of args, it processes that list.
+        # app(args) processes the arguments.
+
+        # However, if we run `notso-glb --help`, args is ['--help'].
+
+        # If we are in "Blender UI mode" (no args provided to script),
+        # original code ran `optimize_and_export` with defaults.
+        # The 'optimize' command REQUIRES 'input_path'.
+        # So if we have no args, we can't run the CLI command easily.
+        # But original code handled "UI mode" by running defaults?
+        # Wait, original code: `if args is None: optimize_and_export(...)`
+        # That assumed `bpy.data.filepath` was set (i.e. open file in Blender).
+
+        if not args and "blender" in os.path.basename(sys.argv[0]).lower():
+            # UI Mode fallback (Running inside blender with open file, no CLI args)
+            from notso_glb.exporters import optimize_and_export
+
+            optimize_and_export(
+                output_path=DEFAULT_CONFIG["output_path"],
+                use_draco=DEFAULT_CONFIG["use_draco"],
+                use_webp=DEFAULT_CONFIG["use_webp"],
+                max_texture_size=DEFAULT_CONFIG["max_texture_size"],
+                force_pot_textures=DEFAULT_CONFIG["force_pot_textures"],
+                analyze_animations=DEFAULT_CONFIG["analyze_animations"],
+                check_bloat=DEFAULT_CONFIG["check_bloat"],
+                experimental_autofix=DEFAULT_CONFIG["experimental_autofix"],
+            )
+            return
+
+        if not args:
+            # If no arguments provided, print help to stderr preserving colors
+            # We do this by invoking the 'optimize' command's help but redirected to stderr
+            old_stdout = sys.stdout
+            sys.stdout = sys.stderr
+            try:
+                # invoke 'optimize --help' so we see the command args, not the group help
+                app(args=["optimize", "--help"], standalone_mode=False)
+            except (SystemExit, typer.Exit):
+                pass
+            finally:
+                sys.stdout = old_stdout
+            sys.exit(1)
+
+        # Single-command Typer apps automatically use the command as default
+        # No need to prepend 'optimize' - Typer handles this
+        app(args=args, standalone_mode=True)
+
+
+if __name__ == "__main__":
+    main()

notso_glb/exporters/__init__.py

@@ -0,0 +1,8 @@
+"""GLB/glTF export functions."""
+
+from notso_glb.exporters.gltf import import_gltf, optimize_and_export
+
+__all__ = [
+    "import_gltf",
+    "optimize_and_export",
+]