Dithering: Difference between revisions
Jump to navigation
Jump to search
No edit summary |
No edit summary |
||
| Line 7: | Line 7: | ||
==Use in games== | ==Use in games== | ||
[[File:Org-1-.png| | [[File:Org-1-.png|350px|right|thumb|Sega Genesis Game Lion King showing unblended dithering]] | ||
[[File:Policenauts_PC98.png| | [[File:Policenauts_PC98.png|350px|right|thumb|Unblended dithering in Policenauts for the PC98]] | ||
{| class="wikitable sortable" style="width:74%; text-align:left;" | {| class="wikitable sortable" style="width:74%; text-align:left;" | ||
|+Dithering implementation varies wildly across console generations depending on video bandwidth, VRAM constraints, and hardware-level video filters. The table below breaks down how different major systems handle dithering and how those choices manifest on modern flat-panel displays.<br>Many older computer games also used dithering, though unlike with console games, it was not expected for the dithering to be blended into solid colors or proper transparency due to the sharper output of PC monitors. Of particular note are games for Japanese computers such as the PC-88/98, which often featured heavy use of dithering. | |+Dithering implementation varies wildly across console generations depending on video bandwidth, VRAM constraints, and hardware-level video filters. The table below breaks down how different major systems handle dithering and how those choices manifest on modern flat-panel displays.<br>Many older computer games also used dithering, though unlike with console games, it was not expected for the dithering to be blended into solid colors or proper transparency due to the sharper output of PC monitors. Of particular note are games for Japanese computers such as the PC-88/98, which often featured heavy use of dithering. | ||
Latest revision as of 16:49, 28 June 2026

Dithering is a technique to increase the amount of color and shading that can be done on a system. The effect is achieved by using lines or dots which are then blurred by the low quality NTSC signals (composite or RF) that the system uses. Modern computers use higher quality analog VGA (RGBHV) or digital HDMI, DVI, or DisplayPort signals, which means that the dithering ends up being sharp and unblurred.
Before diving in
[edit | edit source]Use in games
[edit | edit source]

| System | Generation / Era | Primary Use Case | Hardware Architecture and Constraints | Modern Display Reality |
|---|---|---|---|---|
| Sega Genesis | 4th Generation (16-bit) | Pseudo-transparency (e.g., Sonic the Hedgehog waterfalls) and shading. | Severe master color palette restrictions; heavily relied on low-quality Composite/RF NTSC signal blur to blend vertical line and checkerboard patterns. | Raw dither lines and mesh patterns appear completely sharp and unblended, destroying the intended transparency effects. |
| Super Nintendo | 4th Generation (16-bit) | Transparency and color depth expansion in rare titles (e.g., Metal Warriors, Kirby's Dream Land 3). | Native hardware transparency support meant dithering was rarely required, though some titles utilized pseudo-high-resolution vertical line patterns. | Dithering patterns remain completely unblended and sharp unless specific high-resolution blending shaders are applied. |
| PlayStation (PS1) | 5th Generation (32-bit) | Smooth shading gradients (e.g., Silent Hill) and pseudo-transparency checkerboards. | 15-bit color depth limitation for standard gameplay rendering framebuffers caused severe color banding without a dither pass. | High-contrast checkerboard noise becomes highly visible, particularly in dark scenes or shadows. |
| Sega Saturn | 5th Generation (32-bit) | Transparency effects (e.g., Castlevania: Symphony of the Night dialogue boxes). | Complex dual-forward-rendering GPU architecture lacked robust alpha-blending transparency support for VDP1 sprites over VDP2 backgrounds. | Mesh patterns appear as an obvious, solid checkerboard grid rather than transparent overlays. |
| Nintendo 64 | 5th Generation (64-bit) | Color depth expansion and gradient masking (e.g., GoldenEye 007, Perfect Dark). | Slow, unified memory bandwidth forced a drop to 16-bit color. However, the Reality Coprocessor featured built-in, hardware-level Video Interface (VI) filters. | Hardware-level de-dither and horizontal anti-aliasing filters blur the dither pattern naturally, resulting in a low-noise but notoriously "muddy" or soft image. |
| Sega Dreamcast | Generation Transition (5th to 6th) | Banding mitigation in High Color modes (e.g., Sonic Adventure, Soulcalibur sky gradients). | PowerVR2 GPU natively supports 24-bit True Color, but developers dropped framebuffers to 16-bit to preserve the tight 8MB of Video RAM. Applies an ordered hardware dither. | Originally masked well on standard consumer CRTs via blurry 480i composite/RF cables. However, because the console natively supports 480p VGA, these checkerboard patterns become sharply exposed and highly visible on modern flat panels, emulation, or digital HDMI mods. |
| PlayStation 2 | 6th Generation | Banding mitigation in performance-heavy titles (e.g., Silent Hill 3, Grand Theft Auto: San Andreas). | Strict 4MB eDRAM bandwidth limits forced some developers to drop the framebuffer from 32-bit True Color down to 16-bit color, triggering the Graphics Synthesizer's hardware dither. | Hardware dithering artifacts are sharply exposed. Can also be easily confused with horizontal "jailbar" noise caused by poor Analog-to-Digital conversion on modern TVs. |
| Original Xbox | 6th Generation | Standard rendering pipelines. | Robust memory bandwidth allowed the system to render almost entirely in native 32-bit True Color (16.7 million colors). | Software-level dithering artifacts are virtually non-existent; image noise is strictly limited to analog cable interference. |
Emulation
[edit | edit source]
The intended effects of dithering are often lost in emulation due to PCs typically using VGA or HDMI signals. The dots or lines appear as they actually are with no blurring. Options:
- Accept the unblended dithering.
- Modern emulators (such as DuckStation and Ymir) offer internal rendering features to address dithering artifacts and color depth limitations directly in the graphics pipeline by default. Using the recommended settings in these emulators is the most effective way to eliminate dithering issues entirely. For Nintendo 64 emulation, use ParaLLEl-RDP for emulating hardware-level video interface (VI) filters which will help the dithering as well.
- Scaled dithering: Scales the dither pattern to match the resolution scale of the emulated GPU. This makes the dither pattern much less obvious and distracting at higher resolutions while preserving the original rendering logic.
- True color rendering: In practice,
PlayStation games stored colour in 15 bits. 24-bit colour mode was mostly used for still images. This enhancement forces the precision of colors output to the console's framebuffer to use the full 8 bits of precision per channel (24-bit True Color). It is especially useful on modern non-CRT displays, producing significantly smoother gradients. - True color debanding: Applies modern dithering techniques internally during rendering (as opposed to a post-processing shader step) to further smooth out gradients when true color rendering is enabled. Because this works within the internal renderer, it is faster, more precise, requires no tweaking of thresholds, and results in no loss of detail.
- Toggle hardware VI filters (N64 specific): For Nintendo 64 emulation, users can choose whether to emulate the original hardware Video Interface filters. Keeping VI filters enabled (specifically the hardware de-dither and anti-aliasing) replicates the original console's smooth, dither-free presentation. Conversely, disabling these filters (often called a "De-blur" option) sharpens the 3D geometry drastically but instantly exposes the raw, raw checkerboard dither patterns that the hardware originally hid.
- Use a blurring or NTSC shader (trying to replicate the same amount of blur as the original signal that was output by original hardware), but users often apply excessive blur using this signal shaders, which only partially mask the dithering anyway, while significantly degrading overall image clarity in the process. For a much cleaner and more realistic presentation, it is highly recommended to apply cable and signal shaders only when used in tandem with the internal emulator rendering enhancements (such as true color rendering) mentioned above.
- Use a dithering shader designed to just selectively blend the dithering but does not blend the rest of the image. While NTSC filters naturally blend dithering as a side effect of analog signal simulation, dedicated dithering shaders isolate and blend these patterns algorithmically while keeping the rest of the image sharp. There are several different shaders that selectively blend dithering patterns, to varying degrees of success. Certain patterns can be difficult to selectively blend without false positives.
- mdapt[1] selectively blends checkerboard and vertical line patterns, and has settings for tweaking the algorithm.
- gdapt[2] is a simpler, more aggressive variant of mdapt intended to handle dithering encountered in Genesis/Mega Drive games
- cbod[3] or "Conditional Blending of Dither" is another implementation of selective dither blending. It appears to have a bit more blur than other algorithms.
- snes-hires-blend[4] blends the vertical line patterns that appear at 512px width only, while doing nothing for 256px graphics. It is intended to be used in a few SNES games like Kirby's Dream Land 3 where it used vertical line patterns in a pseudo-hires mode to achieve translucency on CRTs. This shader has zero false positives when used as intended.
- sgenpt-mix[5] or "Sega Genesis Pseudo Transparency Mixer" is a modern, highly flexible shader designed to blend vertical lines (pseudo-transparency) and checkerboard patterns. It includes adjustable blend levels and mitigations to significantly minimize false positives on text and HUD elements compared to older shaders like mdapt.
Further reading
[edit | edit source]References
[edit | edit source]- ↑ https://github.com/libretro/common-shaders/tree/master/dithering/shaders/mdapt
- ↑ https://github.com/libretro/common-shaders/tree/master/dithering/shaders/gdapt
- ↑ https://github.com/libretro/common-shaders/tree/master/dithering/shaders/cbod-v1
- ↑ https://github.com/libretro/common-shaders/blob/master/crt/shaders/snes-hires-blend.cg
- ↑ https://github.com/libretro/slang-shaders/tree/master/dithering/shaders/sgenpt-mix