Skip to main content
Version: v5.3

Why use an IafViewer EVM instead of a native viewer embed

Overview​

A application can show Autodesk Platform Services (APS) designs, or content from any other third-party viewer, in two ways:

  • Through the matching IafViewer Enhanced Viewing Mode (EVM) on {{IafViewerDBM}}.
  • By embedding the native viewer, such as the Autodesk Viewer (LMV), directly in the application.

This page explains why the EVM is usually the better fit, and when a native embed still makes sense. It uses APS as the worked example, but the same reasoning applies to every EVM.

Recommendation: Use the APS EVM on {{IafViewerDBM}} when your application uses modelComposition, Mapbox GIS, View3D or View2D, clusters, or layouts with several modes. Choose a native LMV embed only when the application is APS-only and you want to own the viewer's hosting and lifecycle without the viewer stack. LMV extensions and the direct viewer API are available inside the EVM too. See LMV toolkit access without leaving the EVM.

One session, many EVMs​

IafViewer is made up of several viewing modes. Each one starts from the best toolkit in its domain and is then aligned to the same property and callback framework, so the modes can run together. See IafViewer Overview and How prop groups fit together.

modelComposition → which models / clusters / federation
│
├── view3d (how — Twinit BIMPK)
├── aps (how — Autodesk designs)
├── view2d
├── gis (where — Mapbox context)
└── arcgis (where — ArcGIS / Esri GIS context)

Every EVM shares three languages, so your application describes the session once and each EVM renders it:

  • modelComposition: what's in the session. Models, federation type (SingleModel, Project, or MultiModel), clusters with their map placement (center, bearing, altitude), disciplines, and layers. View3D reads model IDs, APS reads design URNs (evmMode: 'aps'), and GIS reads the same clusters to place outlines and markers. The composition is persisted once and shared by every mode.
  • Property Store: how each EVM is configured. There's one prop group per mode (view3d, view2d, aps, gis, ue, arcgis, photosphere), built on the same patterns: enable, layout (display mode, alignment, toolbar), camera, rendering modes, selection, isolate and hide, and cutting planes. Session-wide settings, such as i18n, sit alongside them. If you know view3d.camera, you already know the shape of aps.camera.
  • Callback Store: what your application hears back. Selection, isolate, and camera changes arrive as callbacks with aligned shapes. For example, view3d.onCameraUpdate and aps.callbacks.onApsCameraChange share one pose payload, so logic such as persisting a camera or syncing a selection panel is written once.

The Property Store and Callback Store are a logical split. Both arrive as props on {{IafViewerDBM}}, and together they form the "props in, callbacks out" contract. The Unreal Engine and Photosphere EVMs follow the same contract. See Integration Patterns.

Because the languages are shared, each EVM is a renderer choice for the same AEC session, not a separate application subsystem, as long as it's configured appropriately. Switching or combining renderers, such as View3D beside Mapbox, APS on Mapbox, or a UE window next to GIS, changes which prop groups are enabled. It doesn't change how your application models its data or reacts to events. Cross-EVM orchestration still lives in your application, but it works over one vocabulary instead of gluing unrelated SDKs together.

This approach means:

  • Composition strategies (SingleModel, Project, MultiModel, clusters, and disciplines) don't depend on the viewer.
  • Geo-referencing concepts, such as map placement, overlay vs side-by-side layout, and cluster center, bearing, and altitude, are shared across View3D and APS.
  • Improvements in one mode, such as federated GIS, glass, cutting planes, or outline quality, are built once in IafViewer and reused or mirrored in sibling EVMs where the underlying engine allows.

The APS EVM isn't a packaged copy of the Autodesk viewer. It's Autodesk viewing as a peer of View3D inside that unified session.

Integration patterns the EVMs enable​

PatternIafViewer leverWith a native LMV embed only
Mixed sources on a map (BIMPK and APS outlines)clusteredModels with evmMode: 'aps' and GIS federated modes. See APS models on Mapbox.Custom map, custom outline pipeline, and custom selection
Map with detail widgets (Geo BIM APS)gis.initial.enableOverlay: false, gis.onModelSelect, and side panes with aps.enable per URNTwo unrelated viewers and hand-rolled sync
Multi-trade clusters (BIMPK and APS trades)The same modelComposition cluster shape for View3D model IDs and APS URNsDuplicate cluster models in application state
High fidelity (UE) with context (GIS, ArcGIS, Photosphere)Several EVM instances with one prop vocabulary. See UE with ArcGIS, Overview Map, and Photosphere.A one-off integration per vendor

A native LMV embed solves one cell of this matrix: the Autodesk canvas. IafViewer EVMs are built to compose the whole matrix, which is what reference apps such as Geo BIM, federated GIS, and UE stacks demonstrate.

APS as "View3D for Autodesk data"​

For teams that already use {{IafViewerDBM}} and view3d, the APS EVM is deliberately parallel, not a second product API. aps integrates the same way as view3d, through modelComposition and the props and callbacks framework. Only the data source differs: APS design URNs instead of models.

ConcernView3DAPS EVM
Enable and layoutview3d.enable, layout, toolbaraps.enable, aps.layout. See IafViewer APS.
Camera observationview3d.onCameraUpdateaps.callbacks.onApsCameraChange, with the same payload shape
Rendering modesShaded, glass, and othersaps.rendering.mode, including glass alongside shaded and wireframe variants
Scene interrogationSelection, isolate, hideaps.selection, aps.cuttingPlanes, sliced and hidden dbId values
Session chromeToolbar, i18n, permissionsThe same shell. APS uses LMV dbId values, not element IDs.

APS rendering is designed for close parity with View3D: glass, slice and ghosting strategies, and appearance preferences. These are implemented on LMV because HOOPS draw modes don't apply there, but the props your application sets stay familiar.

The learning curve for developers is mostly URNs and scopes instead of model IDs, not a new viewer architecture.

What IafViewer adds on top of LMV​

A native LMV embed gives you the Autodesk viewer. The APS EVM adds the AEC platform behavior that IafViewer provides for View3D and GIS, adapted to LMV.

Rendering and review​

  • Glass and related ghosting and slice strategies through aps.rendering.mode and its glass options, matching View3D glass workflows.
  • Cutting planes in named, absolute, and box modes through aps.cuttingPlanes, mapped to LMV cut planes. This is the same concept as View3D cutting planes.

Camera and federation​

  • Camera callbacks aligned with view3d.onCameraUpdate, so application code and map sync don't fork.
  • Viewer-owned camera sync. Don't drive the map and model cameras independently. See IafViewer GIS (Mapbox).

Map outlines​

  • Outlines for Mapbox (GlbDraco outlines, aps.config.modelOutlineQuality, cluster placement, and a marker fallback) come from IafViewer and Graphics Service, not from LMV.
  • One modelComposition gives your application Geo BIM: BIMPK outlines, APS outlines, and mixed clusters.

Composition and persistence​

  • modelComposition persistence, federation types, and cluster metadata (center, bearing, altitude) are shared with View3D GIS projects.
  • Multi-URN model sets, a primary URN, and aps.callbacks.onApsModelsChange follow the same thinking as federated, multi-model View3D. See Loading multiple models.

Platform shell​

  • Layout modes (such as split and fullscreen), multi-instance EVM windows, toolbar, notifications, i18n, and permissions use one integration style, whether the pixels come from HOOPS or LMV.

A native LMV embed doesn't give you more LMV power than the EVM, because extensions and the direct viewer API are available inside the APS EVM too. Choose the APS EVM when you want the same review, geo, and composition story as View3D, with Autodesk as the geometry source.

Improvements in one mode benefit the others​

IafViewer shares strategies across EVMs instead of duplicating them in each application:

  • Cluster orchestration: View3D and APS clusters share the same composition context, GIS seeding, and UI groups.
  • Outlines and the federated map: APS outlines use the same GIS placement pipeline as View3D outlines. APS adds URN resolution and Extra Derivatives downloads.
  • Overlay policy: One rule ties APS clusters to the GIS overlay setting: any APS cluster turns gis.initial.enableOverlay off.
  • Rendering vocabulary: APS rendering follows View3D glass and slice behavior on top of LMV.

When GIS placement, cluster editing, or federated modes improve, APS on the map benefits without every application integrating the Autodesk viewer again.

APS EVM vs native LMV embed​

LensAPS as an IafViewer EVMNative LMV in a app
ApproachOne modelComposition, many EVMs; mixed BIMPK, APS, UE, and GIS patternsA second viewer stack; composition lives in application code
Developer languageThe same as view3d, gis, and the Property StoreAutodesk viewer documentation plus custom glue code
Geo, map, and clustersBuilt in (APS on Mapbox, Geo BIM APS)Build it or bolt it on
Review features (glass, cutting planes, slice)Prop-driven and aligned with View3D, with several developer-friendly optionsImplement on the raw LMV API, with custom code and domain knowledge for each added method
Camera and multi-view syncShared camera callback shape; sync owned by IafViewerCustom
Outlines on the mapGraphics Service outline pipeline, with several quality options for outline modelsNot available from LMV alone; needs a custom implementation
Long-term platformGains from work across EVMs (UE, ArcGIS, Photosphere patterns)Isolated from that work
Multi-instance layouts (split windows)aps.layout and platform layout patternsCustom UI only
LMV extensions and direct viewer APIonApsReady (payload.viewer, payload.apis) and aps.config.initial; cooperate with IafViewer sync and GISThe same LMV APIs; you own the lifecycle and integration
APS-only, with no viewer stackHeavier than neededCan be simpler

For developers who already work with , the APS EVM feels structured because it extends the viewer they already configure, not because APS is simpler than the Autodesk viewer. The initial friction of URNs, tokens, and dbId values is real. But maintaining a parallel native LMV integration inside every geo-federated or multi-trade product usually costs more.

LMV toolkit access without leaving the EVM​

The APS EVM isn't a props-only wrapper. aps.callbacks.onApsReady gives your application the same LMV viewer instance it would hold in a hand-rolled embed, plus helper APIs:

  • payload.viewer: GuiViewer3D, or Viewer3D when aps.config.initial.enableDefaultUi is false. payload.namespace is Autodesk.Viewing, and payload.document and payload.viewableNode are the loaded document and viewable.
  • payload.apis.client: LMV helpers for camera, rendering, cutting planes, navigation, viewables, and element properties.
  • payload.apis.server: GraphicsService calls to APS for models, status, metadata, properties, Extra Derivatives, and downloads.

You can also configure the viewer when it's created:

  • aps.config.initial.extensions: load any Autodesk Viewer extension, for example Autodesk.DocumentBrowser or Autodesk.Measure. Other keys in aps.config.initial are passed to the LMV viewer constructor.
  • aps.config.sdkVersion: pin the LMV SDK version (default 7.100).

Custom UI, extensions, and direct viewer calls therefore live inside the EVM. Coordinate with IafViewer where it owns state, so your code and the props don't conflict. For example, avoid pushing camera changes while the GIS overlay is active, and let aps.selection drive selection and visibility. For details, see IafViewer APS.

When a native embed makes sense​

Choosing a separate native LMV embed is a hosting and lifecycle decision, not a question of LMV power. With a native embed there's no {{IafViewerDBM}}. Your application owns SDK bootstrap, token handling, document loading, disposal, and every integration, including composition, GIS, persistence, and sync.

A native embed fits when:

  • The application is APS-only.
  • The application must adopt Autodesk SDK features faster than IafViewer releases can wrap them.

The IafViewer Overview notes that the full power of a third-party toolkit may require using the toolkit directly. For APS, that means calling LMV for anything IafViewer props don't wrap yet, which you can do through onApsReady without leaving the EVM.

For unified composition, geo-referenced AEC, mixed sources, clusters, and layouts that combine a map, widgets, and optional UE, ArcGIS, or Photosphere, the APS EVM is the aligned integration surface. Native LMV is the engine underneath one branch of that tree, not a substitute for the tree.