Toggle search
Toggle menu
4.9K
5.5K
229
46.8K
VR & AR Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Single-pass stereo rendering

From VR & AR Wiki
More actions

Single-pass stereo rendering is a group of real-time graphics techniques that produce the left-eye and right-eye images of a stereoscopic frame from one traversal of the scene, instead of rendering the whole scene once per eye. The engine traverses and culls the scene once, and the second view is produced by viewport switching, GPU instancing, an API "multiview" extension or dedicated GPU hardware.[1][2] Engines and vendors use several names for it: Unity has used the names single-pass (double-wide) and single-pass instanced rendering, Unreal Engine calls its version Instanced Stereo Rendering, the Khronos Group and Meta use "multiview", and NVIDIA's hardware features are Single Pass Stereo and Multi-View Rendering.[3][4][5]

The technique exists because a head-mounted display needs two views every frame, and the two views are almost identical. Rendered in the conventional way, as two serial passes, a stereo frame costs about twice as much CPU, driver and geometry work as a single view.[2][6] Single-pass methods mainly reduce that CPU and driver overhead. Instancing-based methods do not reduce the number of triangles that have to be rasterized and shaded for both eyes, and Meta's documentation says GPU performance is "unchanged largely".[6][7] Single-pass stereo can be combined with GPU-side rendering optimizations; NVIDIA pairs its Single Pass Stereo hardware with Lens Matched Shading, which NVIDIA says avoids rendering many pixels that would otherwise be discarded before the image is sent to the headset.[8]

Reviewed 4 October 2026. Checked every claim against the cited Khronos, Vulkan, DirectX, NVIDIA, Unity, Unreal, Meta and Apple documentation, the Everitt and Vlachos slides, the Unity and Oculus blog posts, and the Johansson, Marbach, Hübner, Nah and YORO papers (metadata via Crossref). About review dates.

How it works

The cost of rendering two views

In a typical frame, an engine culls the scene, builds a list of draw calls, binds state for each object and submits the work to the GPU. Cass Everitt of Oculus pointed out at SIGGRAPH 2016 that the two images of a stereo pair show the same scene at the same moment from almost the same camera position, yet "generating two almost identical images actually costs approximately 2x with conventional stereo", because the driver does not know the frames are almost identical.[2] NVIDIA's GeForce GTX 1080 whitepaper describes the same problem: rendering each eye separately "results in twice the amount of work for the entire pipeline, starting from the driver and the OS, and all the way down to the GPU's raster backend".[8]

Some of this work is not view-dependent at all. Unity's first optimization, which it called multi-pass, shared the shadow map generation between the eyes and replaced two per-eye frustum culls with one cull against a combined frustum that contains both eyes' view volumes. Each eye then draws slightly more geometry than it strictly needs, which Unity judged a better trade than culling twice.[1] Everitt's notes describe the same combined-eye frustum and add that an application can build one command stream that works for both eyes, each eye with its own view and projection transform, even without any API support.[2] Single-pass stereo goes further: it traverses the render loop once and makes the GPU, the driver or the shader produce both views from the same submitted work.[1]

Main approaches

Approach How the second view is produced Examples
Multi-pass (baseline) The render loop, or parts of it, runs once per eye, each eye with its own render target Unity multi-pass mode[3]
Geometry shader duplication A geometry shader emits each primitive twice and routes the copies to two viewports or texture layers Studied by Marbach (2009) and Johansson (2016)[6][9]
Double-wide render target Each object is drawn twice in a row into the left and right halves of one double-width target, switching the viewport between draws Unity single-pass stereo (Unity 5.4)[1]
Instanced stereo (stereo instancing) Each draw call is instanced with twice the instance count; the vertex shader uses the instance ID to pick the eye's matrices and output layer or viewport Unity single-pass instanced, Unreal Engine Instanced Stereo[1][4]
API multiview The application issues one draw; the driver replicates it into the layers of a texture array and exposes a view index to shaders OpenGL ES OVR_multiview, Vulkan multiview, Direct3D 12 view instancing[10][11][12]
GPU hardware projection Fixed-function hardware takes one geometry stream with two vertex positions and routes each to its eye NVIDIA Single Pass Stereo (Pascal), Multi-View Rendering (Turing)[8][13]

Double-wide rendering

Switching render targets between consecutive draw calls is expensive, and on most platforms at the time a render target array index could only be written from a geometry shader, which costs GPU time and forces changes to existing shaders. Unity's first single-pass mode therefore used one render target twice as wide as an eye buffer. Every object was drawn twice in succession, once into each half, and the engine changed only the viewport between the two draws. Both eyes' view and projection matrices were bound at the same time, and a shader variable, unity_StereoEyeIndex, selected which pair to use. To cut state changes further, Unity ordered draws left, right, right, left instead of strictly alternating. Unity's engineers wrote that this "isn't exactly twice as fast as Multi-Pass", because culling and shadows were already shared and each eye still needed its own draw and a viewport switch, and that the double-wide layout complicated post-processing.[1]

Instanced stereo

Instanced stereo replaces the pair of draws with one instanced draw. In the form described by Mikael Johansson in the Journal of Computer Graphics Techniques, an application replaces each draw call with its instanced equivalent (for example glDrawArraysInstanced in OpenGL) and passes an instance count of two; the vertex shader then reads the instance ID and transforms each vertex with the left or the right eye's matrices.[6] The remaining difficulty is routing the two copies to two different places. Johansson's portable version transformed vertices into the left or right half of a single viewport and used a user-defined clip plane to keep each copy on its own side, while noting that NVIDIA's NV_viewport_array2 and AMD's AMD_vertex_shader_viewport_index extensions allow the viewport to be chosen directly in the vertex shader.[6]

Unity's version, released for Direct3D 11 in Unity 2017.2, renders into a two-slice render target array. It requires the Direct3D 11 feature that lets the vertex shader write the render target array index (VPAndRTArrayIndexFromAnyShaderFeedingRasterizer), doubles the instance count of every draw (or sets it to two if the draw was not instanced), and decodes the instance ID into the eye index. Unity wrote that this "literally halve[s] the number of draw calls" on the API side and removes the viewport change between eyes.[1] Johansson wrote that stereo instancing had recently gained attention in the game development community, citing two 2015 presentations: Timothy Wilson's "High Performance Stereo Rendering for VR" at the San Diego Virtual Reality Meetup and Alex Vlachos's "Advanced VR Rendering" talk for Valve at GDC 2015.[6][14]

Multiview

Multiview moves the replication into the graphics API and driver. In the Khronos OVR_multiview extension, the application attaches a texture array to a framebuffer, and draw calls "are instanced into each corresponding element of the texture array". Shaders read the built-in gl_ViewID_OVR to compute view-specific values such as the vertex position.[10] Unity's engineers described the practical difference from instanced stereo: with multiview the driver, not the vertex shader, selects the render target slice, and the view ID is used only to compute view-dependent state.[1] The base extension allows only the output position to depend on the view; OVR_multiview2 relaxes that restriction so that outputs such as reflection vectors can also vary per view.[15] Everitt noted that early implementers could make any vertex shader output view-dependent at no additional cost, so restricting view dependence to the position brought no benefit.[2]

Everitt also explained why the Oculus design used texture arrays rather than several bound framebuffers: different framebuffers could have very different configurations, and direct hardware support for multiple views was easier with array targets. The team also considered a fixed-function design, which would have simplified porting, but chose a model in which every vertex shader has to be rewritten.[2]

GPU hardware: Single Pass Stereo and Multi-View Rendering

NVIDIA's Pascal-generation GeForce GTX 1080, announced in May 2016, added a Simultaneous Multi-Projection (SMP) unit to the PolyMorph Engine, placed at the end of the geometry pipeline in front of the raster unit. It can process geometry through up to 16 projections that share a viewpoint, with up to two projection centers offset along the X axis.[8][16] NVIDIA calls the use of those two centers for VR "Single Pass Stereo": the application runs vertex processing once but outputs two positions for each vertex, one per eye, and the SMP hardware routes each version to the correct eye. NVIDIA states that scene submission, driver and OS scheduling and geometry processing are then performed only once, "effectively halving the geometry workload compared to traditional VR rendering".[8] In OpenGL, the feature is exposed through the NV_stereo_view_rendering extension, which adds a gl_SecondaryPositionNV output for the second eye and depends on NV_viewport_array2.[17]

With the Turing architecture in 2018, NVIDIA extended the idea as Multi-View Rendering (MVR), which raises the number of views in one pass from two to four. All four views are position-independent and "can shift along any axis in the projective space", where Single Pass Stereo views could vary only in the x-direction, and attributes other than position can be view-dependent.[13] NVIDIA's OpenGL sample uses the OVR_multiview extensions for MVR and NV_stereo_view_rendering for Single Pass Stereo.[5]

History

Single-pass generation of several views predates consumer VR headsets. Thomas Hübner, Yanci Zhang and Renato Pajarola presented a multi-view point splatting method in 2006 that used GPU programmability to render multiple stereo views, including sub-pixel wavelength-selective views, in a single rendering pass rather than one pass per view.[18] In 2009, Jonathan Marbach's paper at the ACM Symposium on Virtual Reality Software and Technology analysed when geometry shaders and layered rendering, which allow "multiple images to be generated in a single geometry pass", actually improve the performance of stereo and multi-view rendering for virtual environments.[9]

The modern techniques took shape as VR headsets approached consumer release. The first draft of the OVR_multiview extension, whose contact is Cass Everitt of Oculus and whose contributors include John Carmack and engineers from Qualcomm, NVIDIA, Google, Epic, ARM, Sony Mobile and Imagination Technologies, is dated 17 October 2014.[10] At GDC 2015, Valve's Alex Vlachos compared four ways to render stereo on one GPU: running the CPU code twice and amplifying geometry in a geometry shader (both rated "BAD"), resubmitting command buffers ("GOOD", Valve's solution at the time) and instancing to double the geometry ("BETTER", with half the API calls and better cache coherency).[14]

Engine and hardware support arrived during 2016. Unreal Engine 4.11, covered by CG Channel on 6 April 2016, added Instanced Stereo Rendering; Epic reported improvements of about 14% in CPU time and about 7% on the GPU in its Bullet Train demo "with no work required".[4][19] NVIDIA announced Single Pass Stereo with the GeForce GTX 1080 on 6 May 2016.[16] Unity 5.4, released in July 2016, added an optimized single-pass stereo rendering feature, previously called Double Wide Rendering, which rendered both viewports in a single pass.[20] In October 2016, at its Oculus Connect 3 conference, Oculus said multiview was already available for native apps on some Gear VR devices, with CPU improvements of up to 50% on internal apps, and that it would roll out multiview for Unreal and enter beta for Unity by the end of the year.[21] The Vulkan equivalent, VK_KHR_multiview, whose contact is Jeff Bolz of NVIDIA (last modified 28 October 2016), and was promoted into core Vulkan 1.1, which Khronos released on 7 March 2018.[11][22]

Support then spread across platforms. Road to VR reported in July 2017 that Apple's Metal 2 added single-pass stereo, which "allows the GPU to render to the left and right eye with a single draw call instead of one for each eye".[23] Unity 2017.2 added Stereo Instancing (single-pass instanced) for XR devices on Direct3D 11, including the HTC Vive, Oculus Rift and Windows Mixed Reality headsets, available on Windows 10 and HoloLens.[1] NVIDIA's Turing Multi-View Rendering followed in September 2018.[13]

Graphics API support

API Mechanism Shader view index Notes
OpenGL / OpenGL ES OVR_multiview, OVR_multiview2 gl_ViewID_OVR Requires OpenGL 3.0 or OpenGL ES 3.0; implementations must support at least two views, and six are recommended[10][15]
Vulkan VK_KHR_multiview, core since Vulkan 1.1 ViewIndex (gl_ViewIndex in GLSL) Configured per render pass with VkRenderPassMultiviewCreateInfo[11]
Direct3D 12 View instancing SV_ViewID (shader model 6.1 or later) Up to four view instances (D3D12_MAX_VIEW_INSTANCE_COUNT); hardware support is reported in tiers 1 to 3[12]
Direct3D 11 Instanced draws with the render target array index written from the vertex shader Derived from the instance ID Used by Unity's single-pass instanced mode on Windows[1]
OpenGL on NVIDIA GPUs NV_stereo_view_rendering (Single Pass Stereo) gl_SecondaryPositionNV for the second eye Shipping in NVIDIA release 367 drivers and later[17]
Metal Vertex amplification amplification_id attribute The GPU fetches vertex data once and runs the vertex function once per amplified copy[24]
WebGL 2 OVR_multiview2; OCULUS_multiview in the Meta Quest browser gl_ViewID_OVR OCULUS_multiview supports multisampled anti-aliasing; not available in WebGL 1.0[25]

Apple's documentation describes vertex amplification as more efficient than encoding a command several times with the same vertices "because the GPU fetches the vertex data only once", and says apps typically use it to render the same vertices to different texture layers or viewports.[24] For visionOS, Apple's Compositor Services offers a "layered" texture layout in which each view is a slice of a single texture; in its WWDC 2023 session on Metal for immersive apps, Apple called the layered layout "the optimal layout since it allows you to render your scene in a single pass while still maintaining foveated rendering".[26][27]

In engines and platforms

Unity

The current Unity manual lists three stereo render modes. Multi-pass performs a render pass for each eye and has the widest shader compatibility. Single-pass instanced "renders the scene in a single pass using instanced draw calls", which the manual says significantly reduces CPU usage and slightly reduces GPU usage compared with multi-pass. Multiview is a variation of single-pass instanced that replaces it on devices supporting the multiview extension. The manual lists Android devices with the multiview extension (such as Meta Quest headsets), PlayStation VR and PlayStation VR2, and tethered Windows devices as supported platforms; on Windows the supported XR graphics APIs are Direct3D 11 and 12, and the GPU must support the VPAndRTArrayIndexFromAnyShaderFeedingRasterizer feature.[3]

Shaders have to be written for the mode. Unity's built-in shaders, its Universal and High Definition render pipelines and Surface shaders already support single-pass instanced rendering, but custom shaders need macros such as UNITY_VERTEX_INPUT_INSTANCE_ID, UNITY_VERTEX_OUTPUT_STEREO and UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO to select the correct eye.[28] An unmodified shader renders to only one eye, the first slice of the stereo texture array, and Unity does not support single-pass instanced rendering with Shader Graph in its built-in render pipeline.[3]

Unreal Engine

In Unreal Engine, Instanced Stereo is a project setting. Epic's documentation says it "lessens the performance impact of XR in UE", requires an engine restart and shader recompile once enabled, and works in the base pass and early-z pass with static meshes, skeletal meshes, sprite particles and mesh particles.[29] When the feature arrived in Unreal Engine 4.11, Epic noted that a handful of rendering features, distance field ambient occlusion among them, did not yet work with it.[4] For mobile headsets the engine has a separate Mobile Multi-View setting, which the documentation describes as similar to Instanced Stereo, providing "an optimized path for Stereo Rendering on the mobile device's CPU".[29]

Meta Quest and mobile VR

Meta's developer documentation describes the behaviour on its headsets in the same words for both mobile multiview and PC stereo instancing: "objects are rendered once to the left eye buffer, then duplicated to the right buffer automatically with appropriate modifications for vertex position and view-dependent variables such as reflection". It requires OpenGL ES 3 or Vulkan on Android and Direct3D 11 on PC, and Meta recommends it for applications that are CPU-bound or draw-call bound.[7] For web content, Meta's Quest browser exposes OCULUS_multiview by default. Meta says that "only CPU-bound experiences will benefit from multi-view" and that a CPU usage reduction of 25% to 50% is often possible.[25]

Performance

Published measurements agree that the main saving is on the CPU and driver side:

  • Everitt reported at SIGGRAPH 2016 that, once devices with multiview support were available, real and synthetic apps showed CPU time reductions of 33% to 49%, and power use fell by 27% to 33%. He added that multiple views are "unlikely to ever be 'free'" relative to a single view.[2]
  • Johansson measured stereo instancing against two-pass rendering, geometry shader duplication and brute-force rendering of three building information models on a laptop GeForce GTX 980M, the target being the 90 Hz (11.1 ms) frame rate of the consumer Oculus Rift and HTC Vive. With view frustum culling only, the scenes were mostly CPU-bound and stereo instancing cut average frame times on the exterior camera paths by 27% to 52% compared with two-pass rendering; the variant using NV_viewport_array2 was faster than the portable clip-plane version. With occlusion culling added, stereo instancing reduced average and maximum frame times by 20% to 23% against two-pass and 5% to 21% against geometry shader duplication on the interior paths.[6]
  • Unity's engineers, presenting results from Unite Austin 2017, found that single-pass and single-pass instanced both gave a large CPU advantage over multi-pass but differed little from each other, because most of the CPU overhead is removed by moving to a single traversal and draw calls themselves are relatively cheap on multithreaded drivers.[1]
  • NVIDIA states that combining Single Pass Stereo with its Lens Matched Shading feature lets Pascal deliver "up to 2x performance improvement for VR" compared with a GPU without Simultaneous Multi-Projection.[8]

The limits are just as consistent. Meta's documentation says single-pass rendering "primarily reduces CPU usage, and the GPU performance is unchanged largely".[7] Johansson notes that stereo instancing, like geometry shader duplication, does not reduce the number of triangles rendered each frame, so the amount of geometry to be transformed, rasterized and shaded can still be the limiting factor.[6] In the same study, geometry shader duplication performed about as well as stereo instancing on one of the three models (the hotel), and on the dormitory model's interior paths geometry shader duplication alone was faster than stereo instancing combined with wall batching and geometry instancing.[6] NVIDIA lists three conditions under which its Multi-View Rendering gives the largest gains: complex vertex processing, dense geometry and a large overlap of content between views.[13]

Beyond two views

The multiview mechanism is not limited to stereo pairs. The OVR_multiview specification mentions configurations with two inset views per eye to raise sample density in wide field-of-view rendering.[10] Everitt described this as a simple form of foveated rendering: a narrow (for example 60 degree) inset view rendered at the same resolution as a wide (for example 120 degree) view, so that four views could give both stereo and an inset in one pass.[2] NVIDIA's Turing Multi-View Rendering likewise targets four arbitrary views.[13] Apple's documentation gives cascaded shadow maps as a non-stereo use of vertex amplification.[24]

Research

Academic work has looked at reducing the remaining cost of two views. Jae-Ho Nah, Yeongkyu Lim, Sunho Ki and Chulho Shin proposed the Z2 traversal order for tile-based mobile GPUs (Computational Visual Media, 2017), which renders corresponding screen tiles of the left and right views in turn or simultaneously to exploit their spatial adjacency; in trace-driven hardware simulation it reduced external memory bandwidth and increased rendering performance.[30] Everitt had made a similar point in 2016, observing that corresponding tiles of the two eye images contain nearly the same geometry, so binning once for both eyes would likely beat binning twice, and rendering corresponding tiles together could reduce memory bandwidth through texture cache sharing.[2]

Other methods avoid shading all of the second view. Oculus's stereo shading reprojection, published for Unity in 2017, uses depth buffer information to reproject the pixels rendered for one eye into the other eye and fills the gaps with an additional rendering pass; in a test scene with deliberately heavy pixel shading on a GeForce GTX 970, Oculus measured whole-frame GPU time falling from 5.6 ms to 4.4 ms, a saving of about 21%.[31] A 2025 paper at the ACM MobiSys conference by Xingyu Chen and colleagues, "You Only Render Once" (YORO), generates both binocular images from one monocular rendering using per-pixel attributes; the authors report average power savings of 27% and a 115.2% increase in frame rate, with binocular image quality similar to state-of-the-art mobile VR rendering solutions.[32] Unlike single-pass stereo, which still rasterizes and shades both views, these approaches synthesize part or all of one view from the other.

See also

References

  1. ↑ 1.00 1.01 1.02 1.03 1.04 1.05 1.06 1.07 1.08 1.09 1.10 Rob Srinivasiah (2017-11-21). "How to maximize AR and VR performance with advanced stereo rendering". Unity Blog. Unity Technologies. https://web.archive.org/web/20231201103727/https://blog.unity.com/technology/how-to-maximize-ar-and-vr-performance-with-advanced-stereo-rendering. Retrieved 2026-10-04.
  2. ↑ 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 Cass Everitt (2016). "Multiview Rendering (presentation slides with notes)". Moving Mobile Graphics course, SIGGRAPH 2016. Arm Community. https://community.arm.com/cfs-file/__key/communityserver-blogs-components-weblogfiles/00-00-00-20-66/5_2D00_mmg_2D00_siggraph2016_2D00_multiview_2D00_cass.pdf. Retrieved 2026-10-04.
  3. ↑ 3.0 3.1 3.2 3.3 "Introduction to stereo rendering". Unity Manual (Unity 6.6). Unity Technologies. https://docs.unity3d.com/Manual/SinglePassStereoRendering.html. Retrieved 2026-10-04.
  4. ↑ 4.0 4.1 4.2 4.3 Alexander Paschall. "Unreal Engine 4.11 Released!". Unreal Engine Blog. Epic Games. https://web.archive.org/web/20170208114155/https://www.unrealengine.com/blog/unreal-engine-4-11-released. Retrieved 2026-10-04.
  5. ↑ 5.0 5.1 "gl_multi_view_rendering (sample README)". nvpro-samples. NVIDIA. https://github.com/nvpro-samples/gl_multi_view_rendering. Retrieved 2026-10-04.
  6. ↑ 6.0 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 Mikael Johansson (2016). "Efficient Stereoscopic Rendering of Building Information Models (BIM)". Journal of Computer Graphics Techniques, vol. 5, no. 3. https://jcgt.org/published/0005/03/01/. Retrieved 2026-10-04.
  7. ↑ 7.0 7.1 7.2 "Using Single Pass Stereo Rendering and Stereo Instancing". Meta Horizon OS Developers. Meta Platforms. https://developers.meta.com/horizon/documentation/unity/unity-single-pass/. Retrieved 2026-10-04.
  8. ↑ 8.0 8.1 8.2 8.3 8.4 8.5 "NVIDIA GeForce GTX 1080: Gaming Perfected (whitepaper)". NVIDIA. NVIDIA Corporation. 2016. https://international.download.nvidia.com/geforce-com/international/pdfs/GeForce_GTX_1080_Whitepaper_FINAL.pdf. Retrieved 2026-10-04.
  9. ↑ 9.0 9.1 Jonathan Marbach (2009-11-18). "GPU acceleration of stereoscopic and multi-view rendering for virtual reality applications". Proceedings of the 16th ACM Symposium on Virtual Reality Software and Technology (VRST 2009), pp. 103-110. ACM. doi:10.1145/1643928.1643953. https://doi.org/10.1145/1643928.1643953. Retrieved 2026-10-04.
  10. ↑ 10.0 10.1 10.2 10.3 10.4 "OVR_multiview (OpenGL and OpenGL ES extension specification, revision 6)". Khronos OpenGL Registry. Khronos Group. 2018-10-19. https://registry.khronos.org/OpenGL/extensions/OVR/OVR_multiview.txt. Retrieved 2026-10-04.
  11. ↑ 11.0 11.1 11.2 "VK_KHR_multiview(3)". Vulkan Documentation. Khronos Group. https://docs.vulkan.org/refpages/latest/refpages/source/VK_KHR_multiview.html. Retrieved 2026-10-04.
  12. ↑ 12.0 12.1 "D3D12 View Instancing Functional Spec". DirectX-Specs. Microsoft. https://microsoft.github.io/DirectX-Specs/d3d/ViewInstancing.html. Retrieved 2026-10-04.
  13. ↑ 13.0 13.1 13.2 13.3 13.4 Swaroop Bhonde, Mahalakshmi Shanmugam (2018-09-24). "Turing Multi-View Rendering in VRWorks". NVIDIA Technical Blog. NVIDIA. https://developer.nvidia.com/blog/turing-multi-view-rendering-vrworks/. Retrieved 2026-10-04.
  14. ↑ 14.0 14.1 Alex Vlachos (2015-03). "Advanced VR Rendering (presentation slides)". Game Developers Conference 2015. Valve. https://media.steampowered.com/apps/valve/2015/Alex_Vlachos_Advanced_VR_Rendering_GDC2015.pdf. Retrieved 2026-10-04.
  15. ↑ 15.0 15.1 "OVR_multiview2 (OpenGL and OpenGL ES extension specification)". Khronos OpenGL Registry. Khronos Group. 2018-10-19. https://registry.khronos.org/OpenGL/extensions/OVR/OVR_multiview2.txt. Retrieved 2026-10-04.
  16. ↑ 16.0 16.1 Andrew Burnes (2016-05-06). "Introducing The GeForce GTX 1080: Gaming Perfected". GeForce News. NVIDIA. https://www.nvidia.com/en-us/geforce/news/geforce-gtx-1080. Retrieved 2026-10-04.
  17. ↑ 17.0 17.1 "NV_stereo_view_rendering (OpenGL extension specification, revision 3)". Khronos OpenGL Registry. Khronos Group. 2017-11-25. https://registry.khronos.org/OpenGL/extensions/NV/NV_stereo_view_rendering.txt. Retrieved 2026-10-04.
  18. ↑ Thomas Hübner, Yanci Zhang, Renato Pajarola (2006). "Multi-view point splatting". Proceedings of GRAPHITE 2006, pp. 285-294. ACM. doi:10.1145/1174429.1174479. https://doi.org/10.1145/1174429.1174479. Retrieved 2026-10-04.
  19. ↑ Jim Thacker (2016-04-06). "Epic Games releases Unreal Engine 4.11". CG Channel. https://www.cgchannel.com/2016/04/epic-games-releases-unreal-engine-4-11/. Retrieved 2026-10-04.
  20. ↑ Arti Sergeev (2016-07-28). "Unity 5.4 Released". 80 Level. https://80.lv/articles/unity-5-4-released. Retrieved 2026-10-04.
  21. ↑ The Oculus Team (2016-10-07). "Oculus Developer Updates from OC3". Meta for Developers Blog. Meta Platforms. https://developers.meta.com/vr/blog/oculus-developer-updates-from-oc3/. Retrieved 2026-10-04.
  22. ↑ "Khronos Group Releases Vulkan 1.1". Khronos Group. Khronos Group. 2018-03-07. https://www.khronos.org/news/press/khronos-group-releases-vulkan-1-1. Retrieved 2026-10-04.
  23. ↑ Ben Lang (2017-07-01). "Apple Adds VR Rendering Essentials to MacOS via Metal 2". Road to VR. https://roadtovr.com/apple-adds-vr-rendering-essentials-to-macos-metal-2-single-pass-stereo-direct-to-display/. Retrieved 2026-10-04.
  24. ↑ 24.0 24.1 24.2 "Improving rendering performance with vertex amplification". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/metal/improving-rendering-performance-with-vertex-amplification. Retrieved 2026-10-04.
  25. ↑ 25.0 25.1 "Multiview WebGL Rendering". Meta Horizon OS Developers. Meta Platforms. https://developers.meta.com/vr/documentation/web/web-multiview/?locale=en_GB. Retrieved 2026-10-04.
  26. ↑ "Discover Metal for immersive apps (WWDC23 session 10089)". Apple Developer. Apple. 2023-06. https://developer.apple.com/videos/play/wwdc2023/10089/. Retrieved 2026-10-04.
  27. ↑ "LayerRenderer.Layout.layered". Apple Developer Documentation. Apple. https://developer.apple.com/documentation/compositorservices/layerrenderer/layout/layered. Retrieved 2026-10-04.
  28. ↑ "Single-pass instanced rendering and custom shaders". Unity Manual (Unity 6.6). Unity Technologies. https://docs.unity3d.com/Manual/SinglePassInstancing.html. Retrieved 2026-10-04.
  29. ↑ 29.0 29.1 "XR Performance Features in Unreal Engine". Unreal Engine Documentation (5.8). Epic Games. https://dev.epicgames.com/documentation/en-us/unreal-engine/xr-performance-features-in-unreal-engine. Retrieved 2026-10-04.
  30. ↑ Jae-Ho Nah, Yeongkyu Lim, Sunho Ki, Chulho Shin (2017-12). "Z2 traversal order: An interleaving approach for VR stereo rendering on tile-based GPUs". Computational Visual Media, vol. 3, no. 4, pp. 349-357. doi:10.1007/s41095-017-0093-5. https://doi.org/10.1007/s41095-017-0093-5. Retrieved 2026-10-04.
  31. ↑ Jian Zhang, Simon Green (2017-08-03). "Introducing Stereo Shading Reprojection for Unity". Meta for Developers Blog. Meta Platforms. https://developers.meta.com/horizon/blog/introducing-stereo-shading-reprojection-for-unity/. Retrieved 2026-10-04.
  32. ↑ Xingyu Chen, Xinmin Fang, Shuting Zhang, Xinyu Zhang, Liang He, Zhengxiong Li (2025-06-23). "You Only Render Once: Enhancing Energy and Computation Efficiency of Mobile Virtual Reality". Proceedings of the 23rd Annual International Conference on Mobile Systems, Applications and Services (MobiSys 2025), pp. 263-276. ACM. doi:10.1145/3711875.3729133. https://doi.org/10.1145/3711875.3729133. Retrieved 2026-10-04.
Retrieved from "https://vrarwiki.com/index.php?title=Single-pass_stereo_rendering&oldid=46440"