# 3D Rendering

In [computer graphics](graphics.md) 3D rendering is concerned with computing images that represent a projected view of 3D objects through a virtual camera. There are many methods and [algorithms](algorithm.md) for doing so differing in many aspects such as computation complexity, implementation complexity, realism of the result, representation of the 3D data, limitations of viewing and so on.

A table of some common rendering methods follows, including the most simple, most advanced and some unconventional ones. Note that here we talk about methods and techniques rather than algorithms, i.e. general approaches that are often modified and combined into a specific rendering algorithm. For example the traditional triangle rasterization is sometimes combined with raytracing to add e.g. realistic reflections. The methods may also be further enriched with features such as [texturing](texture.md), [antialiasing](antialiasing.md) and so on. The table below should help you choose the base 3D rendering method for your specific program.

The methods may be tagged with the following:

- *2.5D*: primitive 3D, often called [pseudo 3D](pseudo_3d.md) or fake 3D, having significant limitations e.g. in degrees of freedom of the camera
- *off*: slow method usually used for offline (non-realtime) rendering (even though they indeed may run in real time e.g. with the help of powerful GPUs)
- *IO* vs *OO*: [image order](image_order.md) (rendering by pixels) vs [object order](object_order.md) (rendering by objects)

| method                                   | notes                              |
|------------------------------------------|------------------------------------|
|[3D raycasting](raycasting.md)            |*IO off*, shoots rays from camera   |
|[2D raycasting](raycasting.md)            |*IO 2.5D*, e.g. [Wolf3D](wolf3D.md) |
|[beamtracing](beamtracing.md)             |*IO off*                            |
|[billboarding](billboard.md)              |*OO*                                |
|[BSP rendering](bsp.md)                   |*2.5D*, e.g. [Doom](doom.md)        |
|[conetracing](conetracing.md)             |*IO off*                            |
|"[dungeon crawler](dungeon_crawler.md)"   |*OO 2.5D*, e.g. Eye of the Beholder |
|ellipsoid rasterization                   |*OO*, e.g. Ecstatica                |
|flat-shaded 1 point perspective           |*OO 2.5D*, e.g. Skyroads            |
|reverse raytracing (photon tracing)       |*OO off*, inefficient               |
|[image based rendering](ibr.md)           |generating inbetween views          |
|[mode 7](mode7.md)                        |*IO 2.5D*, e.g. F-Zero              |
|[parallax scrolling](parallax.md)         |*2.5D*, very primitive              |
|[pathtracing](pathtracing.md)             |*IO off*, Monte Carlo, high realism |
|[portal rendering](portal_rendering.md)   |*2.5D*, e.g. [Duke3D](duke3d.md)    |
|prerendered view angles                   |*2.5D*, e.g. Iridion II (GBA)       |
|[raymarching](raymaching.md)              |*IO off*, e.g. with [SDFs](sdf.md)  |
|[raytracing](raytracing.md)               |*IO off*, recursive 3D raycasting   |
|segmented road                            |*OO 2.5D*, e.g. Outrun              |
|[shear warp rednering](shear_warp.md)     |*IO*, volumetric                    |
|[splatting](splatting.md)                 |*OO*, rendering with 2D blobs       |
|[triangle rasterization](rasterization.md)|*OO*, traditional in GPUs           |
|[voxel space rendering](voxel_space.md)   |*OO 2.5D*, e.g. Comanche            |
|[wireframe rendering](wireframe.md)       |*OO*, just lines                    |

TODO: Rescue On Fractalus!

TODO: find out how build engine/slab6 voxel rendering worked and possibly add it here (from http://advsys.net/ken/voxlap.htm seems to be based on raycasting)

TODO: VoxelQuest has some innovative voxel rendering, check it out (https://www.voxelquest.com/news/how-does-voxel-quest-work-now-august-2015-update)