Mobile AR Model Pipeline: From CAD to USDZ/GLB

Clients often bring a STEP file of a sofa from a supplier, expecting it to appear in an AR catalog within an hour. Reality: millions of polygons, no UV layout, wrong scale—the asset doesn't work in ARKit or ARCore. Our pipeline solves this at every stage: from CAD import to final USDZ or GLB, consistently maintaining 60 FPS on iPhone 12 and Samsung S21. Over 5+ years, we have completed more than 50 projects for retail, furniture brands, and industry. We guarantee that every asset passes a real-device test before delivery.

Technical Requirements for an AR Asset

Polygon count

For mobile AR, no more than 50,000–100,000 polygons per object. A scene with multiple objects: up to 300,000 total. Higher causes FPS drops on devices without a PRO chip. For simple objects (box, cup), 500–3000 polygons.

According to ARKit Best Practices: "For smooth AR interaction, use models with no more than 100,000 polygons."

Textures

Maximum resolution 2048×2048 pixels. For small objects, 1024×1024. Supported formats:

• iOS/USDZ: PNG or JPEG for diffuse, separate maps for normal, roughness, metallic
• Android/GLB: JPEG preferred for diffuse (smaller size), PNG for transparency

UV layout

No overlaps, no stretching. Particularly important for AR: models are viewed up close, UV artifacts are noticeable.

Scale

1 unit = 1 meter. Mandatory for correct display in ARKit/ARCore. A sofa 2.2 meters wide is 2.2 units in the scene. We check dimensions in Blender using the N-panel before export.

Pivot point

Rotation and placement point at the center of the object's base for furniture, geometric center for others. ARKit positions the model relative to the pivot—if the pivot is off, the object "floats" above the floor.

How to Optimize a CAD Model for AR?

CAD files from manufacturers contain millions of polygons—direct import into AR gives 2 FPS. We convert them using this pipeline:

1. Import STEP into FreeCAD or Fusion 360
2. Export to OBJ/FBX
3. Retopology in Blender (automatic with Remesh modifier, manual for important details)
4. UV and texturing
5. Export to USDZ/GLB

Retopology in Blender is 3 times faster than manual retopology in Maya thanks to the Remesh modifier with adaptive resolution. For complex organic shapes, we use ZBrush followed by retopology in Blender.

AR Asset Creation Pipeline

References → Low Poly Modeling → UV → Texturing → Optimization → Export

We primarily work in Blender (free, powerful, Python API for automation). For organic shapes—ZBrush with retopology in Blender. Textures—Substance Painter for PBR materials.

Geometry optimization

Decimate modifier in Blender with quality control—remove polygons not visible from normal viewing angles. For round objects (vases, wheels) we use shading via normal map instead of geometry: a 16-sided polygon with a normal map looks like a cylinder but has 5 times fewer polygons.

Baking

If the source is a high-poly model (photogrammetry, CAD import), we bake normal maps, ambient occlusion, and curvature in Substance Painter. This gives the detail of a high-poly model with the polygon count of a low-poly one.

Export to AR Formats

For iOS: USDZ—a ZIP archive with USD files and textures. Export via xcrun usdz_converter or Python USD. Textures inside USDZ must be PNG if transparency is needed. We optimize size using TextureConverter with ASTC compression.

For Android: GLB with Draco compression. We use gltf-pipeline:

gltf-pipeline -i model.glb -o model_compressed.glb --draco.compressionLevel 7

This reduces geometry size by 60–80% without noticeable quality loss.

During export, it's important to set the scene correctly: Y-up, meters, forward Z as recommended by RealityKit. Otherwise the model will appear rotated.

Why is Proper UV Layout Important?

UV layout is the foundation of a realistic texture in AR. If it has overlaps or stretching, the model looks unnatural up close. We always create UV layouts with scale in mind: for furniture, 1 meter = 1 unit in UV space. This ensures consistent texture sharpness across all objects in the scene.

Timelines

Comparing USDZ and GLB Formats

Pricing is determined after evaluating references and required texture quality. Package work (10+ models) is billed at a separate rate. To evaluate your project, send references—get an exact cost and timeline.

What's Included

• Consultation on references and technical specifications
• 3D asset in USDZ and GLB formats
• Blender source files
• PBR textures (diffuse, normal, roughness, metallic)
• Integration instructions for ARKit and ARCore
• Asset test on real devices (iPhone, Samsung)
• Guarantee: if the asset fails FPS testing, we rework it for free

We will evaluate your project within 1 day. Get a consultation—just drop us a message.

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.