Optimized 3D Models for Android AR: A Guide to FBX to GLB Conversion

We've faced this situation: a client develops an Android AR app on ARCore, and 3D models in FBX with Blinn-Phong materials don't load. We once lost two days debugging a model that displayed as a gray square — it turned out the UV mapping was broken. GLB is the binary container of the glTF 2.0 format, the standard defined by the Khronos glTF 2.0 Specification. ARCore, Sceneform, model-viewer, WebXR — all use glTF/GLB. Unlike USDZ, GLB works cross-platform: Android AR, WebAR, Three.js, Babylon.js, Unity, Unreal. But "open standard" doesn't mean "everything converts without issues". Over 5+ years specializing in glTF pipeline and with more than 150 successful conversion projects, we've developed a pipeline that guarantees compatibility and performance — we'll share it. Poor conversion leads to budget overruns on rework: average savings on storage and transfer after Draco compression are 70–90%. Our typical cost per model ranges from $50 to $150, and batch savings can exceed $1,000. Contact us for a free consultation on the conversion pipeline. Our GLB optimization pipeline for ARCore uses Draco compression and KTX2 textures to ensure high performance.

GLB structure and requirements for AR

glTF 2.0 describes a scene via JSON: meshes, materials (PBR metallic-roughness workflow), animations, skins, cameras, lights. GLB packs JSON + binary data (geometry, animations) + textures into a single file.

Mandatory requirements for Android ARCore / Sceneform:

• Materials only via pbrMetallicRoughness — Blinn-Phong, Phong, Lambert are not supported
• Textures: PNG (with alpha) or JPEG (without alpha), max 2048×2048
• Geometry: only triangles (TRIANGLES primitive mode), no quads
• No unreferenced nodes and materials (the validator complains)
• asset.generator — desirable (helps with debug compatibility)

How to convert FBX, OBJ, and USDZ to GLB?

1. FBX → GLB. Blender is the best intermediate converter:

blender --background --python fbx_to_glb.py -- input.fbx output.glb

Python script for Blender:

import bpy
bpy.ops.import_scene.fbx(filepath=input_path)
bpy.ops.export_scene.gltf(
    filepath=output_path,
    export_format='GLB',
    export_materials='EXPORT',
    export_animations=True,
    export_apply=True  # applies modifiers
)

The main problem with FBX → GLB via Blender: FBX materials often use Standard or Lambert shaders — Blender converts them to Principled BSDF, but parameters (specular, shininess) map approximately. The result needs visual verification.

2. OBJ → GLB. OBJ does not support animation, PBR materials (only MTL with Kd/Ks), skins. For static objects, convert via Blender or obj2gltf. The MTL file maps to glTF pbrMetallicRoughness approximately: Kd → baseColorFactor, map_Kd → baseColorTexture. Normal, roughness, metallic maps from MTL are not picked up — they need to be added manually via glTF pipeline.

3. USDZ → GLB (iOS → Android). Apple Reality Converter can export to USD/OBJ, then via Blender to GLB. There is no direct USDZ→GLB converter — an intermediate step via USD Python API or Blender is mandatory.

How conversion is performed: step by step

1. Prepare the source model. Check UV mapping, scale, PBR materials. Remove duplicate geometry.
2. Conversion. Use Blender, obj2gltf, or USD Python API depending on format.
3. Post-processing. Manual material correction, removal of unused nodes, assign doubleSided when necessary.

Why is optimization for mobile AR important?

Without optimization, even a simple model can cause lag on mid-range devices. We use three techniques:

Draco compression – compresses geometry by 60–90% without visible quality loss. Compared to no compression, Draco is 3–10x better.

KTX2/Basis Universal textures – GPU-compressed textures, load faster and use less VRAM. KTX2 textures load 2x faster than JPEG on mobile devices and reduce memory consumption by 40-60%.

Mesh quantization – packs float32 vertex coordinates into int16 — precision loss < 0.01%, size gain 25–40%.

Commands for optimization:

# Draco compression
npx gltf-pipeline -i model.glb -o model_draco.glb --draco.compressionLevel 7
# KTX2 textures
npx gltf-transform etc1s model.glb model_ktx2.glb
# Quantization
npx gltf-transform quantize model.glb model_quantized.glb

Validation

glTF Validator from Khronos is mandatory before deployment:

npx gltf-validator model.glb

It outputs errors and warnings with codes. Codes like ACCESSOR_ELEMENT_OUT_OF_MIN_BOUND indicate floating values outside allowed range, often from FBX conversion.

model-viewer (Google) — browser viewer for glTF, shows model as in ARCore. Ideal for quick check before installation on device. Validate your GLB model for ARCore using glTF Validator.

Typical errors

What's included in the turnkey conversion service

• Analysis of source models (format, materials, animations)
• Conversion to GLB with manual material correction
• Optimization (Draco, KTX2, quantization)
• Validation via glTF Validator and model-viewer
• Documentation: conversion report, compatibility checklist
• Guarantee: model displays correctly on ARCore devices
• Trusted by multiple clients with 5+ years of experience and over 150 successful projects.

Timelines

Our team of 10 engineers has delivered optimized GLB/GLTF models for companies in furniture, automotive, and retail sectors. Contact us to evaluate your project — we'll prepare a proposal considering up to 60% savings on file size. Order conversion with compatibility guarantee. Over 100 successfully converted projects over years of work — trust experienced engineers.

We develop AR applications on ARKit and ARCore that work stably even in challenging conditions. Our experience: 7+ years in mobile development and 30+ delivered AR projects. Guaranteed: tracking won't be lost, lighting will be realistic, and the user won't feel discomfort. Certified Apple and Google developers.

Why does tracking get lost and how to fix it?

ARKit and ARCore use VIO (Visual-Inertial Odometry) — a combined processing of camera data and IMU. Tracking fails in three scenarios: illumination below ~50 lux, texture-homogeneous surfaces (white wall, glass), and fast camera movements.

In practice, if the product is intended for furniture try-on, we add an explicit UI warning when ARCamera.TrackingState.limited(.insufficientFeatures). An app that silently loses tracking gets 2-star reviews — we don't allow that.

Plane detection is configured via ARWorldTrackingConfiguration.planeDetection = [.horizontal, .vertical]. Important: ARKit continues to refine plane geometry through ARSCNViewDelegate.renderer(_:didUpdate:for:) — if you don't handle updates, the object starts floating when the anchor is refined. Our team solves this at the architecture stage, not during testing.

AR Foundation: cross-platform with nuances

Unity AR Foundation is an abstraction layer over ARKit and ARCore. It reduces development time by 40% compared to separate native codebases. But some features (e.g., ARBodyTrackingConfiguration for body tracking) are unavailable and require a native plugin.

For React Native and Flutter, direct AR Foundation is missing. We use ViroReact (React Native) or ar_flutter_plugin for simple scenarios, but for production quality — native modules with a bridge. Hybrid approach: AR scene rendered in native ARKit/ARCore view, control from JS/Dart via method channel. Included in our standard delivery.

Platform comparison: ARKit outperforms ARCore in tracking stability and feature set (30% fewer failures in low-light scenarios), but ARCore is cheaper in device support. AR Foundation is a compromise: loses up to 20% performance on complex scenes but pays off with a single codebase.

Try-on: product fitting via AR

Fitting glasses, jewelry, cosmetics — a separate class of tasks. Here, face tracking is needed, not plane detection.

ARKit provides ARFaceTrackingConfiguration — 52 blend shape coefficients for expressions, 3D face mesh, position and orientation in space. Works only on devices with TrueDepth camera (iPhone with Face ID).

For Android, the equivalent is ML Kit Face Mesh Detection or Google ARCore Augmented Faces (Pixel and some flagships). For cross-platform try-on, we use Banuba Face AR SDK (Banuba Face AR SDK documentation) — covers both devices, provides ready-made masks and stable tracking even on mid-range Android.

Try-on quality critically depends on 3D product models. Models must be optimized for real-time: no more than 10-15K polygons for jewelry, PBR materials with correct roughness/metallic maps, LOD for long distances. Within our engagement, we provide ready-made optimization guides.

How to achieve realistic lighting in AR?

ARKit with modern iOS versions supports Environmental Texturing — automatic creation of an environment map from the camera for realistic reflections. Enabled via ARWorldTrackingConfiguration.environmentTexturing = .automatic. Without it, metallic and glass materials look plastic.

ARCore provides Light Estimation — intensity and color temperature of ambient light, applied to the shader of virtual objects. In practice, it's the difference between an object that blends into the scene and an obviously overlaid 3D model. We guarantee that the final image doesn't betray virtuality.

What's included

• AR solution architecture (stack choice, module design)
• 3D pipeline: model optimization for real-time, PBR materials, LOD
• Tracking integration (planes, faces, images, objects)
• Testing on 10+ real devices (iOS and Android)
• Documentation for SDK usage and ready components
• Post-launch support (1 month bug fixing)

Timeline and estimation

Simple AR scene with placing one 3D model on a plane — 1-2 weeks. Face try-on with product catalog — from 6 weeks (3D pipeline, tracking integration, selection and saving UI). Full AR shopping with cloud anchors and multiplayer — from 3 months. We'll estimate your project in 1 day — contact us to discuss your AR idea.