Imagine a user opening your VR app for virtual tours, putting on Cardboard, and finding themselves in the center of a virtual home tour. They look left – kitchen, right – living room, fixate on the TV – a spec sheet pops up. But the reality of mobile VR development is a fight for every millisecond of head tracking latency and managing dozens of high-resolution 360-degree panoramas. We design architecture where latency stays consistently below 20 ms, and content updates on the fly without an App Store release.
Ready to take on your project end-to-end: pin down the requirements, and we will propose the optimal stack – from Unity to native Metal or Vulkan. A typical tour with 10–15 scenes and navigation takes 2–3 weeks. Development cost starts from $3,000. We will evaluate your task within one day.
What Problems Do We Solve?
- Head tracking latency in VR. We use native rendering (Metal on iOS, Vulkan on Android) with direct IMU access. In practice, latency stays below 20 ms – 3–5 times better than WebView.
- Slow panorama loading. Preload adjacent scenes in the background, compress textures to 8K JPEG with mipmap support. Typical loading time savings: 40%.
- Difficulty updating content. Integrate a CMS or config on CDN – new tours appear after editing, without re-certification in stores. Support budget savings: up to 50% (typically $5,000–$10,000 annually).
With 7+ years of experience and 50+ delivered projects, we guarantee stable operation on devices from iPhone SE to Galaxy S24.
Scene Graph Structure for a VR Tour
A tour is a graph. Each point (node) is a 360-degree panorama or 3D scene. The edges of the graph are transitions (hotspots). Data is stored in a JSON config:
View JSON config example
{
"tour_id": "apartment_demo",
"start_node": "living_room",
"nodes": [
{
"id": "living_room",
"type": "equirectangular",
"media_url": "scenes/living_room_8k.jpg",
"hotspots": [
{ "id": "to_kitchen", "target_node": "kitchen",
"position": { "yaw": -45, "pitch": -10 },
"label": "Kitchen" },
{ "id": "info_tv", "type": "info",
"position": { "yaw": 20, "pitch": 5 },
"content": "Samsung QLED 65\"" }
]
}
]
}
The client loads the graph on startup and preloads media of adjacent nodes. For offline mode – cache selected tours with config version checking.
How to Choose the Renderer: WebView or Native?
| Criteria | WebView (Three.js) | Native (Metal/Vulkan) |
|---|---|---|
| Head tracking latency | 50–100 ms (depends on WebView) | <20 ms (direct IMU access) |
| Cardboard VR support | No | Full |
| Content update speed | Instant (server-side) | Requires app update if engine changes |
| Performance | Medium (WebGL) | High (GPU optimization) |
| Development complexity | Low (HTML/JS) | High (Metal/Vulkan/Unity) |
For full VR in Cardboard VR (see Google Cardboard on Wikipedia), native rendering is 3–5 times better in tracking quality. If VR is not required, WebView suffices and is faster to develop.
How to Ensure Smooth Transitions Between Scenes?
A hard jump between 360 scenes creates discomfort in VR. We use one of three approaches:
| Transition type | Description | VR comfort | Complexity |
|---|---|---|---|
| Fade to black | Fade over 0.5 s, standard from Google VR Design Guidelines | High | Low |
| Fade + scale | Scene shrinks/expands | Medium | Medium |
| Video transition | Short "walk-through" clip | High | High |
Teleportation via fade is standard for VR. On non-VR platforms we often use fade+scale, saving production time.
// Unity: coroutine for transition with fade
IEnumerator TransitionToScene(string targetNodeId) {
yield return StartCoroutine(FadeOut(duration: 0.5f));
LoadScene(targetNodeId);
yield return StartCoroutine(FadeIn(duration: 0.5f));
}
Interactive Hotspots: Types and Implementation
Interactive hotspots in 3D space are implemented via raycasting from the gaze vector origin, combined with dwell-based activation requiring 1–2 seconds of sustained fixation. Supported types:
- Navigation – transition to another node.
- Info panel – popup card with text/photo/video.
- Media – play video on a surface (e.g., TV in interior).
- Link – open browser for external action (book, buy).
Hotspots are rendered in world space using billboarding techniques, where the hotspot plane continuously faces the camera via transform.LookAt() combined with apparent-size scaling to ensure constant visual dimension regardless of distance.
Integrating CMS for Content Updates Without a Release
Tours must update without re-submitting to app stores. We integrate an admin panel or store configs on CDN. The app loads the current graph on startup; for offline – caching with versioning. Support cost savings: up to 50% compared to frequent releases.
Deliverables
- Architecture document with scene graph and hotspot types.
- Source code with documentation and CI/CD.
- Instructions for content updates via CMS or config.
- Testing on 5+ real devices (iPhone 12, Galaxy S21, Pixel 6, etc.).
- 3-month warranty on reported bugs.
Process
- Content audit – determine media type (photo/video/3D), number of scenes, update requirements.
- Design – create scene graph, choose renderer and transition scheme.
- Development – implement panorama rendering, head tracking, hotspot interaction, transitions.
- CMS integration – connect content update system without app store release.
- Testing – evaluate head tracking quality in Cardboard mode, performance on budget devices, using profiling tools like Xcode Instruments and Android GPU Inspector to ensure frame timing stays within 16 ms for 60 fps. We also employ GPU compute shaders for image processing and binary search optimization for gaze convergence calculations.
Estimated Timeline
- Basic app for a single tour with photo panoramas and navigation hotspots: 2–3 weeks. Cost starts at $3,000.
- Full platform with CMS, multiple hotspot types, offline mode, and Cardboard VR: 2–3 months. Typical investment $15,000–$30,000.
Contact us for an accurate estimate of your project. Book a consultation – we will help choose the optimal stack and offer transparent pricing.