How assimp/assimp works
Project Type and Purpose
• Assimp is an open-source C++ library (not a service) whose purpose is to import and export 3D file formats into a common in-memory scene representation.
• It also provides post-processing tools (normals/tangents generation, optimization passes, etc.), a C-API wrapper, language bindings (Python, Java, .NET, Rust, etc.), command-line tools, viewer tools, and sample applications.
High-Level File-Structure Analysis
• Top-level directories:
• code/ → C++ implementation modules
• / → public C and C++ headers (API boundary)
• contrib/ → third-party libraries (zlib, RapidJSON, Draco, etc.)
• scripts/ → code generators for some formats
• port/ → language ports and JNI wrappers
• tools/ → command-line tools (assimp_cmd) and viewer (assimp_view)
• samples/ → sample apps demonstrating usage
• test/ → unit tests, regression tests, fuzzers
• packaging/ → installer scripts, packaging targets
Core Components (from README “Repository structure”)
• code/Common – core import/export infrastructure, scene graph data structures
• code/AssetLib/<Format> – format-specific importers/exporters (FBX, Collada, OBJ, etc.)
• code/PostProcessing – mesh and material post-processing pipeline stages
• code/Geometry – geometry-related utilities
• code/Material – material system
• code/Pbrt – PBR exporter module
• code/CApi – C-binding glue for the public C API
• /assimp – public API headers for C and C++ users
• Public APIs
– C++ API (headers in include/assimp)
– C API (code/CApi)
– Language bindings (port/…)
• Core Engine
– Common Core (code/Common)
– Scene Data Model (in Memory)
• Format Modules (code/AssetLib/*)
– Importer Plugins (OBJ, FBX, glTF, …)
– Exporter Plugins (OBJ, STL, 3MF, PBRt, …)
• Post-Processing Pipeline
– Steps: Triangulate, Generate Normals, Optimize, Validate, etc.
• Utilities & Tools
– Command-Line Tool (tools/assimp_cmd)
– Viewer (tools/assimp_view)
– Scripts (scripts/)
• External Dependencies
– Third-party libs (contrib/)
– Build system (CMake)
– Test frameworks (GoogleTest, libFuzzer)
1. User Application → links against Public API → calls Import()
2. Public API → dispatches into C++ Core → Common Core
3. Common Core → loads appropriate Format Module → parses file on disk (IOSystem)
4. Format Module → constructs in-memory Scene Graph
5. Scene Graph → fed into Post-Processing Pipeline → optimized Scene Graph
6. Optionally → Format Module (exporter) → writes out new file format
7. Public API → returns Scene Graph to User Application
8. Tools & Samples → use Public API to import/export/view/test models
9. Language Ports → wrap Public API for other languages
c. Architectural Patterns & Principles
• Plugin-style architecture: each format is a module under AssetLib, registered at runtime via ImporterRegistry.
• Pipeline pattern: post-processing steps are chained, configurable by flags.
• Adapter pattern: IOSystem abstracts file I/O, allowing custom streams.
• Separation of concerns: parsing, scene management, post-processing, and API exposure are distinct layers.
d. Key Technologies & Frameworks
• CMake build system (CMakeLists.txt, presets)
• GoogleTest & GoogleMock for unit testing
• Clang-Format, EditorConfig for code formatting
• libFuzzer for fuzz testing (fuzz/…)
• Third-party libs for compression, XML/JSON parsing, etc.