meshlite 0.2.0__tar.gz

meshlite-0.2.0/.gitignore

@@ -0,0 +1,32 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.eggs/
+build/
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# hello_imgui — runtime layout/window state, not source
+*.ini
+!assets/layouts/*.ini
+
+# OS
+.DS_Store
+Thumbs.db

meshlite-0.2.0/CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+## v0.2.0 (2026-04-12)
+
+Production readiness release.
+
+### New Features
+
+- **User preferences** — all settings (viewport sensitivity, colors, lighting, camera FOV, undo limits) are persisted between sessions via hello_imgui's user pref API
+- **Settings panel** — live sliders and color pickers in the sidebar for viewport, rendering, camera, and history settings with "Reset to Defaults"
+- **Search panel** — fuzzy search across document nodes and operations in the sidebar
+- **Recent files** — tracked automatically on mesh load; accessible from File > Open Recent and the command palette
+- **Drag-and-drop** — drop mesh files onto the window to load them (GLFW backend, Linux)
+- **Cross-platform CI** — GitHub Actions matrix now covers Linux, Windows, and macOS with Python 3.11/3.12/3.13
+
+### Bug Fixes
+
+- **active_task_count leak** — counter was never decremented after task completion
+- **GPU upload retry spam** — failed uploads no longer retry every frame at 60fps flooding the log
+- **Unnecessary mesh clone** — removed a redundant `.clone()` in CommandBus finalize, saving memory per undoable operation
+- **Falsy zero check in Decimate** — setting max_deleted_vertices to 0 no longer silently defaults to unlimited
+- **BasePanel error dedup** — distinct panel errors are now logged instead of silencing everything after the first
+- **Auto repair partial failure** — result message now clearly says "PARTIAL" when self-intersection fix fails
+- **Debug button in production** — removed the CounterOp debug button and `_dev` import from the viewport
+
+### Improvements
+
+- Extracted `FLT_MAX` constant — replaced 5 duplicated 19-digit float literals across decimate/remesh/subdivide
+- Named byte estimation constants in undo history with derivation comments
+- Asset path resolver (`utils/paths.py`) — works in dev, pip-installed, and frozen bundle contexts
+- Operation manifest (`ops/_manifest.py`) — explicit module list for frozen-bundle discovery
+- Shader loader and font loader now use the centralized path resolver
+
+### Technical
+
+- 85 automated tests (77 original + 8 new preferences tests)
+- Cross-platform CI: ubuntu-latest, windows-latest, macos-latest
+- `selected_color` field on `RenderItem` — selection color now driven by preferences
+
+## v0.1.0 (2026-04-12)
+
+Initial public release.
+
+### Features
+
+- **15 mesh operations** with full MeshLib parameter exposure:
+  - File: Open Mesh, Save Mesh As
+  - Repair: Fill Holes, Auto Repair, Remove Duplicates
+  - Inspect: Fix Self-Intersections (Local + Voxel-based)
+  - Mesh Edit: Decimate, Remesh, Subdivide, Laplacian Smooth
+  - Boolean: Union / Intersection / Difference (with node picker)
+  - Transform: Translate, Rotate, Scale, Mirror
+- **VSCode-style UI** with activity bar, dockable panels, dark theme, codicons
+- **MeshInspector-style top toolbar** with 26 tools across 7 groups
+- **Command palette** (Ctrl+Shift+P) with fuzzy search
+- **Snapshot-based undo/redo** (Ctrl+Z / Ctrl+Shift+Z)
+- **Mesh Info panel** with comprehensive statistics
+- **Properties panel** with auto-rendered parameter widgets
+- **Outliner** with visibility toggles and right-click context menus
+- **Status bar** with mesh count, selection, FPS
+- **Async worker dispatch** — operations run on background threads
+- **One-file operation pattern** — adding a new op requires zero edits elsewhere
+
+### Technical
+
+- 5-layer architecture: domain / ops / render / app_state / ui
+- MeshLib 3.1.1.211 backend
+- imgui_bundle 1.92.601 UI
+- moderngl 5.12.0 renderer
+- Python 3.11+ required

meshlite-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,81 @@
+# Contributing to meshlite
+
+Thanks for your interest in contributing! meshlite is an open-source 3D mesh processing desktop app.
+
+## Development Setup
+
+```bash
+git clone https://github.com/syedjameel/meshlite.git
+cd meshlite
+uv venv --python 3.13 .venv
+source .venv/bin/activate
+uv pip install -e ".[dev]"
+```
+
+## Running Tests
+
+```bash
+PYTHONPATH= pytest
+```
+
+> **Note:** If your shell exports `PYTHONPATH` (e.g. for ROS or FreeCAD), clear it before running pytest to avoid plugin conflicts.
+
+## Running the App
+
+```bash
+python main.py
+```
+
+## Adding a New Operation
+
+Adding an operation to meshlite is a **one-file change**. Here's the pattern:
+
+1. Create a file under `src/meshlite/ops/<category>/your_op.py`
+2. Subclass `Operation`, decorate with `@register_operation`
+3. Define `id`, `label`, `category`, `schema` (params), and `run()`
+4. That's it — the op auto-discovers and appears in the command palette, sidebar, properties panel, and toolbar
+
+See `src/meshlite/ops/smooth/laplacian.py` for a clean example.
+
+If you plan to build a standalone bundle (PyInstaller etc.), also add the module path to `src/meshlite/ops/_manifest.py` so it's discovered in frozen mode.
+
+## Architecture Rules
+
+meshlite has 5 layers with strict dependency rules:
+
+```
+ui  ───>  app_state  ──>  ops  ──>  domain
+ |            |            |
+ └─>  render ─┘            └──>  domain
+```
+
+- **domain/** — pure MeshLib wrapper. Only place `meshlib.*` is imported (via `mrm_shim.py`)
+- **ops/** — operations. May import `meshlib` directly for Settings struct construction
+- **render/** — moderngl only. No meshlib, no ImGui
+- **app_state/** — Document, CommandBus, events, preferences. No meshlib, no GL, no ImGui
+- **ui/** — ImGui panels. Imports from `app_state` (not `domain` directly)
+
+Run `pytest tests/test_architecture.py` to verify these rules.
+
+## User Preferences
+
+User-configurable settings live in `app_state/preferences.py` (a plain dataclass with JSON serialization). To make a new value configurable:
+
+1. Add the field to `Preferences` with a sensible default
+2. Read from `self._app.preferences.<field>` in the consumer code
+3. Add a widget in `ui/panels/sidebar_settings.py` if it should be user-facing
+4. Preferences are auto-saved on exit and auto-loaded on startup
+
+## Code Style
+
+- We use `ruff` for linting
+- Type hints on all public functions
+- Docstrings on all public classes and functions
+
+## Pull Request Process
+
+1. Fork + branch from `main`
+2. Make your changes
+3. Run `PYTHONPATH= pytest` — all tests must pass
+4. Run `ruff check src/ tests/` — no errors
+5. Open a PR with a clear description

meshlite-0.2.0/LICENSE

@@ -0,0 +1,33 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  For the complete license text, see <https://www.gnu.org/licenses/gpl-3.0.txt>
+
+meshforge — Copyright (C) 2026 Syed Jameel
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.

meshlite-0.2.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: meshlite
+Version: 0.2.0
+Summary: VSCode-style 3D mesh processing desktop app, powered by MeshLib + ImGui.
+Project-URL: Homepage, https://github.com/syedjameel/meshlite
+Project-URL: Repository, https://github.com/syedjameel/meshlite
+Project-URL: Issues, https://github.com/syedjameel/meshlite/issues
+Project-URL: Changelog, https://github.com/syedjameel/meshlite/blob/main/CHANGELOG.md
+Author: Syed Jameel
+License: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: 3d,imgui,mesh,mesh-processing,meshlib,moderngl,obj,ply,stl,viewer
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: X11 Applications
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.11
+Requires-Dist: imgui-bundle<2.0.0,>=1.6.3
+Requires-Dist: meshlib>=3.0.0
+Requires-Dist: moderngl<6.0.0,>=5.12.0
+Requires-Dist: numpy<3.0.0,>=2.0.0
+Requires-Dist: pyglm<3.0.0,>=2.8.2
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# meshlite
+
+A desktop 3D mesh processing application with a VSCode-inspired interface, powered by [MeshLib](https://meshlib.io/), [moderngl](https://github.com/moderngl/moderngl), and [Dear ImGui](https://github.com/pthom/imgui_bundle).
+
+## Features
+
+**15 mesh operations** with full parameter control:
+
+| Category | Operations |
+|---|---|
+| **File** | Open (STL / OBJ / PLY / GLB / OFF / 3MF), Save As |
+| **Repair** | Fill Holes, Auto Repair, Remove Duplicates |
+| **Inspect** | Mesh Info, Find Self-Intersections (Local + Voxel) |
+| **Mesh Edit** | Decimate, Remesh, Subdivide, Laplacian Smooth |
+| **Boolean** | Union, Intersection, Difference |
+| **Transform** | Translate, Rotate, Scale, Mirror |
+
+**Professional UI:**
+
+- MeshInspector-style top toolbar with grouped icon buttons
+- Activity bar + collapsible sidebar (Outliner, Operations, Search, Settings)
+- Properties panel with auto-rendered parameter widgets
+- Command palette with fuzzy search (`Ctrl+Shift+P`)
+- Mesh Info panel with topology, geometry, and bounding box statistics
+- Snapshot-based undo/redo (`Ctrl+Z` / `Ctrl+Shift+Z`)
+- VSCode "Dark+" theme with codicon glyphs
+- Drag-and-drop file loading (GLFW backend)
+- Recent files list (File menu + command palette)
+- Persistent user preferences (viewport, rendering, camera, history)
+
+**Architecture:**
+
+- Adding a new operation is a **single-file change** — zero edits to UI, toolbar, or registry
+- 5-layer separation: `domain` / `ops` / `render` / `app_state` / `ui`
+- Async worker dispatch — operations run on background threads
+- 85 automated tests with architecture rule enforcement
+- Cross-platform CI (Linux, Windows, macOS)
+
+## Install
+
+### From PyPI
+
+```bash
+pip install meshlite
+meshlite
+```
+
+### From source
+
+```bash
+git clone https://github.com/syedjameel/meshlite.git
+cd meshlite
+uv venv --python 3.13 .venv && source .venv/bin/activate
+uv pip install -e ".[dev]"
+python main.py
+```
+
+## Keyboard Shortcuts
+
+| Shortcut | Action |
+|---|---|
+| `Ctrl+Shift+P` | Command palette |
+| `Ctrl+O` | Open mesh |
+| `Ctrl+S` | Save mesh as |
+| `Ctrl+Z` | Undo |
+| `Ctrl+Shift+Z` | Redo |
+| `F` | Frame all (fit viewport) |
+| Drag file onto window | Load mesh |
+
+## User Preferences
+
+All settings are persisted automatically between sessions:
+
+- **Viewport:** Rotate / zoom / pan sensitivity
+- **Rendering:** Background color, mesh color, selected color, lighting (ambient, specular)
+- **Camera:** Field of view
+- **History:** Undo depth, memory cap
+
+Access via the **Settings** panel in the sidebar (gear icon in the activity bar).
+
+## Adding a New Operation
+
+meshlite's architecture makes it trivial to add operations. Create one file:
+
+```python
+# src/meshlite/ops/smooth/laplacian.py
+
+@register_operation
+class LaplacianSmoothOperation(Operation):
+    id = "smooth.laplacian"
+    label = "Laplacian Smooth"
+    category = "Mesh Edit"
+    schema = ParamSchema((
+        Param("iterations", "int", "Iterations", default=3, min=1, max=100),
+        Param("force", "float", "Force", default=0.5, min=0.01, max=1.0),
+    ))
+
+    def run(self, mesh, params, ctx):
+        # ... meshlib calls ...
+        return OperationResult(mesh=mesh, message="Smoothed")
+```
+
+The operation automatically appears in the command palette, sidebar, properties panel, and toolbar — with zero edits to any other file.
+
+## Architecture
+
+```
+ui  ───>  app_state  ──>  ops  ──>  domain
+ |            |            |
+ └─>  render ─┘            └──>  domain
+```
+
+| Layer | Responsibility | Dependencies |
+|---|---|---|
+| `domain/` | MeshLib wrapper (`mrm_shim.py`), mesh data, I/O | meshlib, numpy |
+| `ops/` | Operations framework, registry, auto-discovery | domain |
+| `render/` | moderngl renderer, GPU mesh, camera, shaders | domain (read-only) |
+| `app_state/` | Document, CommandBus, undo, events, preferences | domain, ops |
+| `ui/` | ImGui panels, theme, toolbar, command palette | all layers (except domain directly) |
+
+## Tech Stack
+
+- **Python 3.11+**
+- [MeshLib](https://meshlib.io/) — mesh processing engine (GPL-3)
+- [imgui_bundle](https://github.com/pthom/imgui_bundle) — Dear ImGui + hello_imgui
+- [moderngl](https://github.com/moderngl/moderngl) — OpenGL rendering
+- [numpy](https://numpy.org/) + [PyGLM](https://github.com/Zuzu-Typ/PyGLM)
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for development setup, code style, and how to add operations.
+
+## License
+
+[GPL-3.0-or-later](./LICENSE) — matches MeshLib's license.

meshlite-0.2.0/README.md

@@ -0,0 +1,135 @@
+# meshlite
+
+A desktop 3D mesh processing application with a VSCode-inspired interface, powered by [MeshLib](https://meshlib.io/), [moderngl](https://github.com/moderngl/moderngl), and [Dear ImGui](https://github.com/pthom/imgui_bundle).
+
+## Features
+
+**15 mesh operations** with full parameter control:
+
+| Category | Operations |
+|---|---|
+| **File** | Open (STL / OBJ / PLY / GLB / OFF / 3MF), Save As |
+| **Repair** | Fill Holes, Auto Repair, Remove Duplicates |
+| **Inspect** | Mesh Info, Find Self-Intersections (Local + Voxel) |
+| **Mesh Edit** | Decimate, Remesh, Subdivide, Laplacian Smooth |
+| **Boolean** | Union, Intersection, Difference |
+| **Transform** | Translate, Rotate, Scale, Mirror |
+
+**Professional UI:**
+
+- MeshInspector-style top toolbar with grouped icon buttons
+- Activity bar + collapsible sidebar (Outliner, Operations, Search, Settings)
+- Properties panel with auto-rendered parameter widgets
+- Command palette with fuzzy search (`Ctrl+Shift+P`)
+- Mesh Info panel with topology, geometry, and bounding box statistics
+- Snapshot-based undo/redo (`Ctrl+Z` / `Ctrl+Shift+Z`)
+- VSCode "Dark+" theme with codicon glyphs
+- Drag-and-drop file loading (GLFW backend)
+- Recent files list (File menu + command palette)
+- Persistent user preferences (viewport, rendering, camera, history)
+
+**Architecture:**
+
+- Adding a new operation is a **single-file change** — zero edits to UI, toolbar, or registry
+- 5-layer separation: `domain` / `ops` / `render` / `app_state` / `ui`
+- Async worker dispatch — operations run on background threads
+- 85 automated tests with architecture rule enforcement
+- Cross-platform CI (Linux, Windows, macOS)
+
+## Install
+
+### From PyPI
+
+```bash
+pip install meshlite
+meshlite
+```
+
+### From source
+
+```bash
+git clone https://github.com/syedjameel/meshlite.git
+cd meshlite
+uv venv --python 3.13 .venv && source .venv/bin/activate
+uv pip install -e ".[dev]"
+python main.py
+```
+
+## Keyboard Shortcuts
+
+| Shortcut | Action |
+|---|---|
+| `Ctrl+Shift+P` | Command palette |
+| `Ctrl+O` | Open mesh |
+| `Ctrl+S` | Save mesh as |
+| `Ctrl+Z` | Undo |
+| `Ctrl+Shift+Z` | Redo |
+| `F` | Frame all (fit viewport) |
+| Drag file onto window | Load mesh |
+
+## User Preferences
+
+All settings are persisted automatically between sessions:
+
+- **Viewport:** Rotate / zoom / pan sensitivity
+- **Rendering:** Background color, mesh color, selected color, lighting (ambient, specular)
+- **Camera:** Field of view
+- **History:** Undo depth, memory cap
+
+Access via the **Settings** panel in the sidebar (gear icon in the activity bar).
+
+## Adding a New Operation
+
+meshlite's architecture makes it trivial to add operations. Create one file:
+
+```python
+# src/meshlite/ops/smooth/laplacian.py
+
+@register_operation
+class LaplacianSmoothOperation(Operation):
+    id = "smooth.laplacian"
+    label = "Laplacian Smooth"
+    category = "Mesh Edit"
+    schema = ParamSchema((
+        Param("iterations", "int", "Iterations", default=3, min=1, max=100),
+        Param("force", "float", "Force", default=0.5, min=0.01, max=1.0),
+    ))
+
+    def run(self, mesh, params, ctx):
+        # ... meshlib calls ...
+        return OperationResult(mesh=mesh, message="Smoothed")
+```
+
+The operation automatically appears in the command palette, sidebar, properties panel, and toolbar — with zero edits to any other file.
+
+## Architecture
+
+```
+ui  ───>  app_state  ──>  ops  ──>  domain
+ |            |            |
+ └─>  render ─┘            └──>  domain
+```
+
+| Layer | Responsibility | Dependencies |
+|---|---|---|
+| `domain/` | MeshLib wrapper (`mrm_shim.py`), mesh data, I/O | meshlib, numpy |
+| `ops/` | Operations framework, registry, auto-discovery | domain |
+| `render/` | moderngl renderer, GPU mesh, camera, shaders | domain (read-only) |
+| `app_state/` | Document, CommandBus, undo, events, preferences | domain, ops |
+| `ui/` | ImGui panels, theme, toolbar, command palette | all layers (except domain directly) |
+
+## Tech Stack
+
+- **Python 3.11+**
+- [MeshLib](https://meshlib.io/) — mesh processing engine (GPL-3)
+- [imgui_bundle](https://github.com/pthom/imgui_bundle) — Dear ImGui + hello_imgui
+- [moderngl](https://github.com/moderngl/moderngl) — OpenGL rendering
+- [numpy](https://numpy.org/) + [PyGLM](https://github.com/Zuzu-Typ/PyGLM)
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for development setup, code style, and how to add operations.
+
+## License
+
+[GPL-3.0-or-later](./LICENSE) — matches MeshLib's license.

meshlite-0.2.0/assets/shaders/mesh.frag

@@ -0,0 +1,43 @@
+#version 330
+
+// Lighting model aligned with MeshInspector/MeshLib's approach:
+// simple Phong (ambient + diffuse + specular) with configurable strengths.
+// No fill light, no rim light — clean and predictable.
+
+in vec3 v_normal;
+in vec3 v_position;
+
+out vec4 f_color;
+
+uniform vec3 light_pos;
+uniform vec3 view_pos;
+uniform vec3 object_color;
+
+// Configurable lighting params - sent from the renderer each frame.
+// Defaults match MeshInspector's typical look.
+uniform float ambient_strength;     // default 0.2
+uniform float specular_strength;    // default 0.4
+uniform float specular_exponent;    // default 35.0
+
+void main() {
+    vec3 N = normalize(v_normal);
+    vec3 L = normalize(light_pos - v_position);
+    vec3 V = normalize(view_pos - v_position);
+
+    // Diffuse (Lambertian)
+    float NdotL = max(dot(N, L), 0.0);
+
+    // Specular (Phong reflection)
+    vec3 R = reflect(-L, N);
+    float spec = pow(max(dot(R, V), 0.0), specular_exponent);
+
+    // Combine
+    vec3 ambient  = ambient_strength * vec3(1.0);
+    vec3 diffuse  = NdotL * vec3(1.0);
+    vec3 specular = specular_strength * spec * vec3(1.0);
+
+    vec3 result = (ambient + diffuse + specular) * object_color;
+    result = clamp(result, 0.0, 1.0);
+
+    f_color = vec4(result, 1.0);
+}

meshlite-0.2.0/assets/shaders/mesh.vert

@@ -0,0 +1,18 @@
+#version 330
+
+in vec3 in_position;
+in vec3 in_normal;
+
+out vec3 v_normal;
+out vec3 v_position;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat3 normal_matrix;
+
+void main() {
+    v_normal = normal_matrix * in_normal;
+    v_position = vec3(model * vec4(in_position, 1.0));
+    gl_Position = projection * view * model * vec4(in_position, 1.0);
+}

meshlite-0.2.0/main.py

@@ -0,0 +1,27 @@
+"""meshlite entry point.
+
+Run with:
+
+    python main.py
+
+or, after ``pip install -e .``:
+
+    meshlite
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+# Allow ``python main.py`` from the project root without installing the package.
+# When installed via ``pip install -e .`` the package is on sys.path already and
+# this insert is harmless.
+_SRC = Path(__file__).resolve().parent / "src"
+if _SRC.is_dir() and str(_SRC) not in sys.path:
+    sys.path.insert(0, str(_SRC))
+
+from meshlite.app import main  # noqa: E402
+
+if __name__ == "__main__":
+    main()