What File Formats Does ArmorPaint Support for Import and Export?

ArmorPaint supports importing OBJ, FBX, glTF/GLB, and Blender .blend files, while exporting to OBJ, PNG textures, and its native JSON-based .armor project format.

ArmorPaint is an open-source 3D texture painting application built on the Armory3D engine. Understanding what file formats ArmorPaint supports for import and export is critical for integrating the tool into your asset pipeline. This guide examines the actual source code implementation to provide definitive, technical answers on file compatibility.

Import File Formats in ArmorPaint

The import system in ArmorPaint is modular, with built-in support for four primary 3D mesh formats. The detection logic resides in paint/sources/io/import_mesh.c, which routes files to specialized loaders based on file extension.

Wavefront OBJ (.obj)

Wavefront OBJ is the most straightforward import format, handled natively without external plugins. In paint/sources/io/import_mesh.c, the system detects the .obj extension and dispatches to import_obj_run for parsing.

// From paint/sources/io/import_mesh.c (lines 27-34)
if (ends_with(path, ".obj")) {
    import_obj_run(path);
    return;
}

The import_obj_run function parses geometry, normals, and UV coordinates directly from the ASCII format.

Blender (.blend)

Blender .blend files receive native support through a dedicated loader. When the filename ends with .blend, the system calls the specialized Blender importer defined in paint/sources/io/import_blend_mesh.c.

// From paint/sources/io/import_mesh.c (lines 29-37)
else if (ends_with(path, ".blend")) {
    import_blend_mesh_run(path);
    return;
}

This allows artists to import meshes directly from Blender without intermediate exports, preserving mesh data through ArmorPaint's direct integration with the Blender file specification.

Autodesk FBX (.fbx)

Autodesk FBX import relies on the plugin system rather than core engine code. The FBX plugin utilizes the ufbx library located in paint/plugins/io_fbx/ufbx/. The UI layer in paint/sources/ui/box_import_mesh.c validates FBX files before handing them to the plugin pipeline.

// From paint/sources/ui/box_import_mesh.c (lines 37-44)
if (ends_with(path, ".fbx")) {
    // Delegates to FBX plugin via ufbx
    io_fbx_import(path);
}

The plugin architecture allows for robust FBX support while keeping the core engine lightweight.

glTF 2.0 (.gltf / .glb)

glTF and GLB files share the same plugin infrastructure as FBX. The UI recognition logic in box_import_mesh.c checks for both .gltf and .glb extensions at lines 55-58, routing them through the import plugin system for modern, efficient transmission format support.

// Extension detection for glTF variants
if (ends_with(path, ".gltf") || ends_with(path, ".glb")) {
    io_gltf_import(path);
}

Export File Formats in ArmorPaint

Export capabilities in ArmorPaint focus on mesh geometry, texture data, and project persistence. Each format serves distinct workflow needs, from asset baking to project archival.

Wavefront OBJ (.obj)

OBJ export is implemented in paint/sources/io/export_obj.c, writing geometry, vertex normals, and UV data to the standard Wavefront specification. The implementation handles both ASCII formatting and coordinate system transformations.

// From paint/sources/io/export_obj.c (lines 10-18, 67-75)
void export_obj_run(const char *path) {
    FILE *fp = fopen(path, "w");
    // Write vertex data
    for (int i = 0; i < vertex_count; i++) {
        fprintf(fp, "v %.6f %.6f %.6f\n", 
                vertices[i].x, vertices[i].y, vertices[i].z);
    }
    // Write face indices...
    fclose(fp);
}

This ensures broad compatibility with other 3D applications that support the decades-old OBJ standard.

PNG Textures (.png)

Texture exports are forced to PNG format by the UI layer. In paint/sources/ui/box_export.c, the box_export_tab_export_textures function sets a strict file-type filter limiting output to PNG images.

// Conceptual extraction from paint/sources/ui/box_export.c
void box_export_tab_export_textures() {
    char *path = dialog_save("Export Textures", "texture.png");
    if (path) {
        // Filter ensures .png extension
        export_texture_png(path);
    }
}

This guarantees lossless compression and alpha channel preservation for painted texture sets.

Native Project Files (.armor)

Project persistence uses a JSON-based .armor format. While not a mesh exchange format, this is the native container for undo/redo history and layer data. The saving mechanism utilizes iron_file_save_bytes to serialize project state.

// Project save logic utilizing iron_file_save_bytes
void project_save(const char *path) {
    char *json_data = project_serialize_to_json();
    iron_file_save_bytes(path, (uint8_t *)json_data, strlen(json_data));
}

These files maintain full editability, unlike the flattened mesh exports.

Summary

• ArmorPaint imports four mesh formats natively: OBJ, Blender .blend, FBX, and glTF/GLB
• OBJ importing uses import_obj_run in paint/sources/io/import_mesh.c (lines 27-34)
• FBX and glTF rely on the plugin architecture in paint/plugins/io_fbx/ and paint/plugins/io_gltf/
• ArmorPaint exports to OBJ meshes, PNG textures, and JSON-based .armor project files
• Texture exports are strictly limited to PNG format via box_export_tab_export_textures in paint/sources/ui/box_export.c

Frequently Asked Questions

Can ArmorPaint import STL files for 3D printing workflows?

No, ArmorPaint does not support STL import according to the source code analysis. The import_mesh.c file only implements detection for .obj, .blend, .fbx, .gltf, and .glb extensions. To use STL models, you must convert them to OBJ format using Blender or other intermediary tools before importing into ArmorPaint.

Does ArmorPaint support exporting to FBX format?

No, ArmorPaint cannot export to FBX format. While the application imports FBX through the io_fbx plugin system, the export functionality in paint/sources/io/ only implements OBJ writing via export_obj.c. For FBX workflows, export as OBJ from ArmorPaint and convert using Blender or Autodesk tools.

What image format should I use for textures exported from ArmorPaint?

ArmorPaint exports textures exclusively as PNG files. The UI code in box_export.c enforces a file-type filter that restricts texture exports to PNG format, ensuring lossless quality and alpha channel support for your painted textures. There is no option to export as JPEG, TIFF, or EXR from the standard export dialog.

How does ArmorPaint handle Blender files differently from OBJ files?

ArmorPaint processes Blender .blend files through import_blend_mesh.c, which reads Blender's native binary format directly, while OBJ files are parsed as ASCII text via import_obj.c. The .blend importer can potentially preserve more mesh attributes specific to Blender's data structure, though both ultimately convert to ArmorPaint's internal mesh representation for painting operations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}