osm2cdr.com

FBX (Filmbox) format: industry-standard 3D pipeline — export OSM 3D buildings to FBX

2026-03-3113 min read
3dmeshautodeskfbxdccanimation
Export formats: FBX

FBX (short for Filmbox, after its parent product) is the industry standard for moving 3D data between DCC packages — Maya, 3ds Max, MotionBuilder, Blender, Cinema 4D, Houdini on one side and Unity, Unreal Engine on the other. The format was developed by the Montreal company Kaydara in 1996 as an internal container for Filmbox, a motion-capture toolkit for VFX and filmmaking. In 2004 Kaydara was bought by Alias, in 2006 Autodesk acquired the entire Alias, and FBX became part of Autodesk's 3D ecosystem. Since then Autodesk has maintained the closed FBX SDK (free download but with a proprietary license that forbids derivative implementations), and FBX became the de-facto format for shipping rigs, skinning, animation takes, materials, cameras, and lights between applications. On osm2cdr.ru fbx_exporter.py runs through Building3DExporter and exports OSM 3D buildings to FBX through the FBX SDK (or Blender CLI with its native FBX exporter): footprints get real heights from building:levels × 3 m, get extruded into prisms, each building receives a dummy Phong material, and the result is saved as binary FBX version 7.4 for Unity 2021+ and Unreal Engine 5 compatibility.

Map generation of Dubai city center

History: Kaydara, Filmbox, Alias, Autodesk

FBX's story starts in Montreal, 1993. The Canadian studio Kaydara Inc. was founded to build motion-capture software for VFX and film production. Their flagship product — Filmbox — captured actor movements through sensors or optical systems, processed animation curves, and applied them to 3D character rigs. In 1996 Kaydara needed an internal format to save Filmbox projects — that's how FBX (short for Filmbox) was born.

Originally FBX was ASCII-only: a textual node tree describing scene hierarchy, meshes, skeletons, animation keyframes. The structure resembled Lisp s-expressions: nested blocks with an identifier and properties. With version 6.x came a binary variant — more compact (~4-5x smaller than ASCII) and faster to load in production.

In 2004, Alias (then Maya's owner) acquired Kaydara for $50M. The goal — integrate FBX as a unified pipeline format between Maya, 3ds Max (then owned by discreet), and MotionBuilder (formerly Filmbox under a new name). In 2006 Autodesk acquired Alias whole — for $182M — and inherited the entire Kaydara/Alias portfolio: Maya, MotionBuilder, the FBX SDK, 3ds Max (through discreet earlier in 2005).

Since 2006 Autodesk has owned FBX. The company ships FBX SDK updates every year (currently FBX SDK 2020+), periodically changing the binary format (FBX 6.x → 7.0 → 7.3 → 7.4 → 7.5 → 7.7). Sadly, breaking changes happen between major versions — an old FBX SDK won't read a new file, and vice versa. That gave rise to the joke: "FBX is a format between any two files of which there's no compatibility, even if both are called FBX."

FBX's main commercial role — exchange between Autodesk tools (Maya/Max/MotionBuilder) and game engines (Unity native importer since 2008, Unreal Engine since 2009). From the 2010s on FBX became the standard game-dev pipeline: artists make models in Maya/Max → export FBX → Unity/Unreal import. The format covers 100% of game-dev needs: rigged characters, animations, skinning, materials, blend shapes (morph targets), cameras, lights.

ASCII vs Binary

FBX, like many older formats, ships in two variants:

Binary (default in modern programs): - Header magic: Kaydara FBX Binary \x00\x1a\x00 (20 bytes) - Version number (uint32, e.g. 7400 for FBX 7.4) - Node tree: each node — endOffset (uint32/uint64), numProperties, propertyListLen, nameLen, name, properties[], children[] - Properties: typed (Y=int16, C=bool, I=int32, F=float32, D=float64, L=int64, R=raw bytes, S=string, and array variants: f/d/l/i/b with optional zlib compression) - Footer with a magic number 0x0102030405

ASCII (deprecated but still supported):

; FBX 7.4.0 project file
; Copyright (C) 1997-2010 Autodesk Inc.
FBXHeaderExtension:  {
    FBXHeaderVersion: 1003
    FBXVersion: 7400
    CreationTimeStamp:  {
        Version: 1000
        Year: 2026
        ...
    }
    Creator: "FBX SDK/FBX Plugins version 2020.0"
}
Objects:  {
    Geometry: 1234567890, "Geometry::Building", "Mesh" {
        Vertices: *N { a: x,y,z,x,y,z,... }
        PolygonVertexIndex: *M { a: 0,1,2,-4,... }
        ...
    }
}

Binary is 4-5x more compact than the equivalent ASCII. 1000 buildings: binary FBX — ~8 MB, ASCII — ~35 MB. Binary also loads 10-20x faster (no text parsing, direct memory copy). ASCII is useful for debugging (open in a text editor and see what's inside) and for diff-friendly version control (readable git diffs). On osm2cdr.ru we write binary FBX 7.4 by default.

Map generation of Kaliningrad city center

What's inside FBX

FBX is a full-DCC format and, unlike geometry-only OBJ or STL, carries nearly everything a production pipeline needs:

Geometry. Meshes with positions, normals, UVs (multi-UV channels), vertex colors, smoothing groups, polygon indices. Quad and n-gon support (unlike STL which is triangle-only).

Materials. Legacy Phong/Lambert/Blinn shaders (specific to Maya/Max workflow). Modern FBX SDK 2020+ adds PBR via FbxSurfacePhong extensions for metallic-roughness — but it's still not a unified standard like glTF.

Textures. Embedded (inside the FBX binary as raw bytes) or external (path references). Embedded is convenient for portability — one file, everything inside; external is for big projects where texture sharing matters.

Rigging. Skeleton hierarchy (a bones tree with rotations/translations), skinning weights (per-vertex bone influence), inverse-bind matrices. That's what makes FBX irreplaceable in character pipelines — there's no other format (except USD) that ships rigs as cleanly.

Animation. Multiple "takes" (animation clips) with keyframes on rotation/translation/scale of each node. Curves can be linear/bezier/auto-tangent. Blend shapes (morph targets) for facial animation.

Scene composition. Cameras with focal length, near/far, aspect ratio. Lights (point/directional/spot/area) with intensity, color, falloff. Locators and null nodes for pivot points. Constraints (parent/aim/orient).

Cached takes. Point cache support (per-frame vertex positions) for very heavy deformations — for example cloth or fluid simulation. That's the alternative to rigging when deformation is too complex for skinning.

Strengths and weaknesses

Strengths. Industry-standard exchange for DCC + game-dev: Maya↔Max↔Unity↔Unreal trade projects almost painlessly via FBX. Rich palette: rigs, skinning, animation, materials, cameras, lights in one file. Binary variant is compact and fast. The official SDK from Autodesk is stable, documented, free to download. The ASCII variant is useful for debugging and git-friendly version control. Native import in every major 3D package (including Blender via built-in FBX I/O addon).

Weaknesses. Closed proprietary spec — no open standard documentation, everything goes through the closed SDK. The SDK license forbids derivative library implementations (Blender uses the SDK directly, or reverse-engineered ufbx C library — the latter works great but doesn't cover all cases). Breaking changes between major SDK versions: a file created by FBX SDK 2020 may fail to open in FBX SDK 2014. Materials are simplified: Phong/Lambert/Blinn — legacy Maya 1990s shaders; PBR support added retrofit and not unified. Binary file size larger than glTF (no built-in mesh compression — no Draco equivalent). With open standards rising (glTF 2.0, USD), FBX is slowly losing ground in new pipelines.

FBX vs glTF vs Alembic vs USD

3D formats for different pipeline needs: - FBX — Autodesk DCC + game-dev. Closed spec. Full rig + animation + materials. - glTF — web and AR/VR. Open Khronos spec. PBR materials, Draco compression. Modern default for realtime. - Alembic (.abc) — VFX/film. Open spec (Sony Pictures Imageworks + ILM, 2010). Baked geometry caches (per-frame vertex positions) without rig — for cloth/fluid simulation export from shot finalization. - USD (Universal Scene Description) — Pixar 2016. Open spec. Layered composition (overrides, references, payloads) for multi-artist film pipelines. Replacing FBX in high-end VFX studios (Pixar, ILM, Weta, DNEG).

In the industry, the common combination is: FBX for rigs+animations (handing off from Maya to Unity), Alembic for baked sim (cloth, hair, fluid from Houdini into Maya), USD for final scene assembly (lighting, look-dev). glTF — for anything web/realtime. New projects increasingly pick glTF or USD; FBX hangs on in legacy game-dev pipelines.

Use cases

Game-dev artist. Builds a building model in 3ds Max or Maya, textures in Substance Painter, exports to FBX, drops into a Unity Assets folder. Unity auto-generates a prefab with MeshRenderer; the Material Editor sees Phong properties. The workflow is familiar to every indie game-dev since the 2010s.

VFX TD (technical director). Processes mocap data in MotionBuilder — actor movements captured by an optical system. Animation curves save to FBX, ship into Maya onto a character rig, then on to final render via RenderMan/Arnold. FBX — the glue of the entire character pipeline.

Indie filmmaker. Creates a scene environment in Blender (including 3D building models from OSM via osm2cdr.ru), exports to FBX, imports into Unreal Engine 5 for real-time virtual production with an LED wall (as on The Mandalorian). FBX lets you ship lighting + cameras + materials, not just geometry.

Architect / urban planner. Exports a district from OSM as FBX, opens in 3ds Max, lays different lighting scenarios for presentation. FBX is nicer than OBJ here because colors/materials per building type are immediately visible in Max.

Educational tool builder. Builds an interactive city tour in Unity (importing an OSM district through FBX), ships as a WebGL build or mobile app. FBX is more convenient than glTF in this case only because Unity's native pipeline has been optimized around FBX for 15 years.

Software

Autodesk Maya. Paid ($1875/year). De-facto VFX and character-animation standard. Native FBX import/export via File → Export Selection → FBX. Maya is the primary FBX authoring tool and supports all features (rigs, skinning, animation, blend shapes).

Autodesk 3ds Max. Paid ($1875/year). Leader in arch-viz and game-dev modeling. Native FBX import/export. Particularly strong in polygon modeling and Arnold rendering for arch-viz.

Autodesk MotionBuilder. Paid (subscription required, ~$1875/year). Specialized for motion capture, character animation, real-time virtual production. FBX — primary file format.

Blender. Free, open-source. FBX import/export via the built-in addon (io_scene_fbx). Export quality improved dramatically since 2.80+; large mesh handling and rig export are now on par with commercial tools. An alternative — ufbx (community C library) for tight integration without the Autodesk SDK.

Unity. Free for personal/indie (revenue < $200K), $2050/year for pro. Most popular indie game engine. FBX — native asset format: drag-drop into the Assets folder and Unity auto-generates a prefab.

Unreal Engine. Free (5% royalty after $1M revenue per platform). AAA-game and virtual-production industry standard. FBX import via Content Browser; materials convert into Material Editor nodes.

Cinema 4D / Houdini. Paid ($60-$70/month and $1995-$4995/year respectively). C4D — motion-graphics champion, Houdini — VFX simulation (fluid, cloth, destruction). Both work natively with FBX as exchange format.

ZBrush. Paid ($895 perpetual or $40/month). Digital-sculpting industry standard. FBX — primary export for handing high-poly sculpts to Maya/Max for retopology.

Pipeline in OSM2CDR

Our fbx_exporter.py inherits from Building3DExporter (like obj_exporter.py, stl_exporter.py, gltf_exporter.py). Pipeline:

  1. Footprint loading. PostGIS returns buildings via WKB (ST_AsBinary) — building polygons with tags height, building:levels, building:material, building.

  2. Calculate building height. Identical to the STL/OBJ pipeline:

  3. height tag (in meters) — priority 1
  4. building:levels × 3.0 m — priority 2

  5. Type-based fallback: apartments → 15 m, house → 5 m, skyscraper → 100 m, default 6 m

  6. Extrusion. Each polygon turns into a prism via trimesh.creation.extrude_polygon. The footprint becomes the bottom face and the top face, walls become vertical quads (FBX supports quads, unlike STL — file-size savings).

  7. Material assignment. Each building gets a Phong material by the building tag:

  8. residential / apartments → beige Phong (ambient=0.3, diffuse=0.8, specular=0.1)
  9. commercial / office → blue Phong with a blue tint
  10. industrial → gray matte
  11. house → red-beige

  12. default → light gray Material name = Mat_<type>_<index> for easy editing in Maya/Max.

  13. FBX scene assembly. Through FBX SDK (or a python-fbx wrapper) we build the scene:

  14. Root node "OSM_Export"
  15. Per-building mesh node with FbxMesh geometry
  16. Material attached through FbxLayerElementMaterial mapping
  17. Optional ground plate as an extra mesh

  18. Default camera (perspective, 35mm focal length) for convenient preview

  19. Export. FbxExporter.Initialize(filepath, fileFormat=FbxIOSettings.eExportFbxBinary), version 7400 (FBX 7.4 — the sweet spot of compatibility with Unity 2021+, Unreal 5, Maya 2020+, Max 2020+).

Coordinates in FBX are meters, Y-up (Autodesk standard). Origin — bottom-south-west bbox corner. On Unity import the default behavior is Y-up → Y-up (no rotation), but in Blender (Z-up) Y becomes Z with an unwrap rotation. Slicer-side rotation is a well-known pain, so many game-devs keep export setting Y-up and run Apply Transformation in Blender after import.

An alternative path without the FBX SDK — export through the Blender CLI. On the backend we run blender --background --python export_fbx.py -- input.glb output.fbx to launch blender headless, which imports an intermediate glTF and exports FBX via its built-in I/O. It's slower (requires blender startup + glTF roundtrip) but avoids the Autodesk SDK license headache for open-source self-hosting.

Map generation of Sydney city center

FAQ

FBX or glTF — what to pick for game-dev? If the target is Unity or Unreal with a legacy pipeline (project started before 2022) — FBX, because all surrounding assets are already FBX, materials are tuned for Unity Standard Shader, and the team is used to it. If it's a new project oriented toward web/mobile/AR — glTF (especially with Draco compression), because glTF is natively supported in Unity 2022+, Unreal 5.2+, and is significantly more compact.

Y-up or Z-up? FBX defaults to Y-up (Autodesk Maya/Max standard). That often conflicts with Blender (Z-up) and game-engines (Unity Y-up = OK, Unreal Z-up = headache). Our export writes Y-up as FBX expects, but on import into a Z-up program you need to rotate 90° on X. Modern FBX importers (Blender 3.0+, Houdini 19+) usually do this automatically.

Which FBX SDK version for best compatibility? FBX 7.4 (binary, version 7400) is the most compatible baseline. Supported by Unity since 2018, Unreal since 4.20, Maya since 2020, Max since 2020, Blender since 2.80, Cinema 4D since R20. FBX 7.5/7.7 have extra features (metadata, more stable binary layout) but may fail to open in older tools.

Why are materials in FBX simplified? FBX materials — legacy Phong/Lambert from the Maya 1990s era. These are intensity-based attributes (ambient/diffuse/specular/emissive color and intensity), without modern PBR (metallic, roughness, normal map sigma). FBX SDK 2020+ added PBR through custom properties, but it's not standardized — every importer interprets it differently. For PBR pipelines, glTF is better, where metallic-roughness is built-in spec.

FBX file size is large — what to do? FBX binary without compression — every position/normal/UV takes 4-8 raw bytes. For a typical 5 km² OSM district (~5000 buildings) that's 20-50 MB FBX. To reduce: (1) export a smaller bbox; (2) merge nearby buildings into one mesh (less per-mesh overhead); (3) drop normals (the shader compiler computes them from faces) — saves 30%. Alternative — export glTF with Draco compression: the same district becomes 2-5 MB.

Open-source alternative to the FBX SDK? ufbx — a C library by Samuli Raivio (single-header, MIT license). Reads binary and ASCII FBX 6.x-7.5, very compact (~5K lines), used in Bevy/Godot/some indie engines. Read-only — no write. For write the open-source alternative is the Blender FBX exporter (reverse-engineered), but it doesn't cover every professional-pipeline edge case.

Sources

Related articles

3DS (3D Studio) format: legacy 3D mesh interchange — export OSM buildings to .3dsWavefront OBJ — 3D Format Since 1990: ASCII Structure, .mtl, and OSM Building ExportglTF — The JPEG of 3D: Khronos's Web, AR/VR, and Games Format, with OSM Building Export
← All articles