# AutoRemesher Dependencies: Complete Guide to Building the Open-Source Remeshing Tool

> Discover the essential AutoRemesher dependencies including Qt, Intel TBB, Eigen, and Geogram. Build the open-source remeshing tool with this complete guide.

- Repository: [Jeremy HU/autoremesher](https://github.com/huxingyi/autoremesher)
- Tags: how-to-guide
- Published: 2026-07-09

---

**AutoRemesher depends on Qt (Widgets, OpenGL, SVG), Intel TBB, Eigen, Geogram, and several bundled third-party libraries including IsotropicRemesher, QtAwesome, and Tiny OBJ Loader, all configured through the `autoremesher.pro` qmake project file.**

The `huxingyi/autoremesher` repository is a cross-platform C++ application for automatic quad-dominant remeshing of 3D models. Understanding the AutoRemesher dependencies is essential for compiling the project from source, as it combines system libraries with vendored third-party code located in the `thirdparty/` directory.

## Core System Dependencies

AutoRemesher is built on top of the Qt framework and uses OpenGL for real-time mesh visualization. These dependencies are declared in the project configuration and integrated throughout the source tree.

### Qt Framework Modules

The project file `autoremesher.pro` declares the required Qt modules using the `QT +=` directive. The application requires **Qt Widgets** for the interface, **OpenGL** for rendering, and **SVG** for icon handling.

The relevant configuration in `autoremesher.pro` includes:

```qmake
QT += core gui widgets opengl svg

```

These modules are utilized throughout [`src/main.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/main.cpp) (application entry point) and the various OpenGL wrapper classes in `src/monochromeopengl*`.

### OpenGL Rendering Backend

The visualization layer relies on **OpenGL** for shader-based rendering. The project includes GLSL shader files in the `shaders/` directory (e.g., `monochrome_core.vert` and `monochrome_core.frag`) and manages shader programs through [`src/monochromeopenglprogram.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/monochromeopenglprogram.cpp).

The initialization of the shader pipeline follows this pattern:

```cpp
// src/monochromeopenglprogram.cpp
MonochromeOpenGLProgram prog;
prog.addShaderFromSourceFile(QOpenGLShader::Vertex,
    QStringLiteral(":/shaders/monochrome_core.vert"));
prog.addShaderFromSourceFile(QOpenGLShader::Fragment,
    QStringLiteral(":/shaders/monochrome_core.frag"));
prog.link();

```

## Mathematical and Parallel Computing Libraries

The remeshing algorithms require high-performance linear algebra and multi-threading capabilities provided by Eigen and Intel TBB.

### Eigen for Linear Algebra

The **Eigen** library is included as a header-only dependency in `thirdparty/eigen/`. It is used throughout the codebase for vector and matrix operations, particularly in geometry calculations.

In [`src/util.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/util.cpp), Eigen types handle 3D point computations:

```cpp
// src/util.cpp
#include <Eigen/Dense>

Eigen::Vector3d computeCentroid(const std::vector<Eigen::Vector3d>& pts) {
    Eigen::Vector3d sum = Eigen::Vector3d::Zero();
    for (const auto& p : pts) sum += p;
    return sum / static_cast<double>(pts.size());
}

```

### Intel TBB for Multi-threading

**Intel Threading Building Blocks (TBB)** is bundled in `thirdparty/tbb/` and provides the parallel execution framework used by the remeshing algorithms. The library is leveraged in [`src/quadmeshgenerator.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/quadmeshgenerator.cpp) to process mesh elements concurrently.

The parallel processing pattern is implemented as follows:

```cpp
// src/quadmeshgenerator.cpp
#include <tbb/parallel_for.h>
#include "isotropicremesher/isotropicremesher.h"

void QuadMeshGenerator::remesh(Mesh& mesh) {
    tbb::parallel_for(size_t(0), mesh.triangles.size(),
        [&](size_t i) {
            // each triangle can be processed independently
            isotropicRemesher::processTriangle(mesh, i);
        });
}

```

## Geometry Processing Engine

The core remeshing functionality relies on Geogram for geometric utilities and the IsotropicRemesher library for the actual mesh generation algorithm.

### Geogram Library

**Geogram** is vendored in `thirdparty/geogram/` and supplies mesh utilities, bounding-box trees, and progress reporting mechanisms. The library provides the foundational data structures upon which the remeshing algorithms operate.

### IsotropicRemesher Algorithm

The **IsotropicRemesher** library in `thirdparty/isotropicremesher/` implements the core isotropic remeshing algorithm. This is the primary algorithmic component that performs the mesh optimization and quad-dominant remeshing. The interface is consumed by [`src/quadmeshgenerator.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/quadmeshgenerator.cpp) to drive the remeshing process.

## Data Import and UI Utilities

Several lightweight dependencies handle file I/O and user interface enhancements.

### Tiny OBJ Loader for Model Import

The **Tiny OBJ Loader** is included as a single-header library in [`src/tiny_obj_loader.h`](https://github.com/huxingyi/autoremesher/blob/main/src/tiny_obj_loader.h). It handles the import of OBJ model files into the internal mesh representation.

The usage in [`src/rendermeshgenerator.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/rendermeshgenerator.cpp) follows this implementation:

```cpp
// src/rendermeshgenerator.cpp
#include "tiny_obj_loader.h"

bool loadObj(const std::string& filename, Mesh& mesh) {
    tinyobj::attrib_t attrib;
    std::vector<tinyobj::shape_t> shapes;
    std::vector<tinyobj::material_t> materials;
    std::string warn, err;
    if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err,
                          filename.c_str())) {
        qWarning() << "Failed to load OBJ:" << QString::fromStdString(err);
        return false;
    }
    // …convert tinyobj data into Mesh…
    return true;
}

```

### QtAwesome and QtWaitingSpinner for Interface Enhancements

**QtAwesome** (located in `thirdparty/QtAwesome/`) provides Font Awesome icons for the Qt toolbar, while **QtWaitingSpinner** (in `thirdparty/QtWaitingSpinner/`) displays a loading animation during long-running remeshing operations. Both are integrated directly into the GUI classes in `src/`.

## Build Configuration

The complete dependency tree is managed through the **qmake project file** `autoremesher.pro`, which includes the `thirdparty/` directories and links against the Qt modules. No external package manager (e.g., vcpkg or Conan) is required to build the project, as all non-Qt dependencies are vendored in the repository.

To build AutoRemesher from source, you must have the Qt development packages installed on your system, while the remaining dependencies (Eigen, TBB, Geogram, IsotropicRemesher, QtAwesome, QtWaitingSpinner, and Tiny OBJ Loader) are compiled directly from the bundled source code.

## Summary

- **Qt** (Core, Widgets, OpenGL, SVG) provides the GUI framework and rendering pipeline, configured in `autoremesher.pro`.
- **OpenGL** powers the real-time mesh visualizer via shaders in `shaders/` and [`src/monochromeopenglprogram.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/monochromeopenglprogram.cpp).
- **Eigen** in `thirdparty/eigen/` handles all linear algebra operations for geometry processing.
- **Intel TBB** in `thirdparty/tbb/` enables multi-threaded remeshing in [`src/quadmeshgenerator.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/quadmeshgenerator.cpp).
- **Geogram** in `thirdparty/geogram/` supplies geometric processing utilities and data structures.
- **IsotropicRemesher** in `thirdparty/isotropicremesher/` implements the core remeshing algorithm.
- **Tiny OBJ Loader** in [`src/tiny_obj_loader.h`](https://github.com/huxingyi/autoremesher/blob/main/src/tiny_obj_loader.h) manages model import.
- **QtAwesome** and **QtWaitingSpinner** in `thirdparty/` provide UI icons and loading indicators.

## Frequently Asked Questions

### Is AutoRemesher a header-only library?

No, AutoRemesher is a complete Qt application with compiled dependencies. While some components like **Eigen** and **Tiny OBJ Loader** are header-only, the project requires compiling source files from **Intel TBB**, **Geogram**, and **IsotropicRemesher**, along with the application's own `.cpp` files in `src/`.

### What version of Qt is required to build AutoRemesher?

The `autoremesher.pro` file specifies `QT += core gui widgets opengl svg`, which is compatible with Qt 5 and Qt 6. You must have the Qt development headers and libraries installed on your system, as these are the only external dependencies not vendored in the `thirdparty/` directory.

### Can I build AutoRemesher without Intel TBB?

No, **Intel TBB** is a mandatory dependency. The remeshing algorithms in [`src/quadmeshgenerator.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/quadmeshgenerator.cpp) explicitly call `tbb::parallel_for` to parallelize mesh processing operations. Removing TBB would require significant refactoring of the parallel execution logic throughout the codebase.

### Where is the isotropic remeshing algorithm implemented?

The algorithm is implemented in the **IsotropicRemesher** library, which is vendored in `thirdparty/isotropicremesher/`. This library is called by the `QuadMeshGenerator` class in [`src/quadmeshgenerator.cpp`](https://github.com/huxingyi/autoremesher/blob/main/src/quadmeshgenerator.cpp) to perform the actual mesh optimization and quad-dominant remeshing.