Parallax mapping

Parallax mappingMain

Community hub

Parallax mapping

8 pages, 0 posts

0 subscribers

Recent from talks

Be the first to start a discussion here.

Recent from talks

Be the first to start a discussion here.

Contribute something

About hubMembersContent overviewUpdatesRules

Main reference articles

Parallax mapping

View on Wikipedia

from Wikipedia

Parallax mapping with shadows

Parallax mapping (also called offset mapping or virtual displacement mapping) is an enhancement of the bump mapping or normal mapping techniques applied to textures in 3D rendering applications such as video games. To the end user, this means that textures such as stone walls will have more apparent depth and thus greater realism with less of an influence on the performance of the simulation. Parallax mapping was introduced by Tomomichi Kaneko et al., in 2001.^[1]

Parallax mapping is essentially a method by which rough or uneven surfaces on a 2D texture can be "pulled out" to take on the appearance of a 3D surface. Technically, this is implemented by displacing the texture coordinates at a point on the rendered polygon by a function of the view angle in tangent space (the angle relative to the surface normal) and the value of the height map at that point. At steeper view-angles, the texture coordinates are displaced more, giving the illusion of depth due to parallax effects as the view changes. This effect is commonly used for rendering windows in order to fake 3D interiors for example.

Parallax mapping, as described by Kaneko et al., is a single step process that does not account for occlusion. Subsequent enhancements have been made to the algorithm incorporating iterative approaches to allow for occlusion and accurate silhouette rendering.^[2]

Steep parallax mapping

[edit]

Steep parallax mapping is one name for the class of algorithms that trace rays against heightfields. The idea is to walk along a ray that has entered the heightfield's volume, finding the intersection point of the ray with the heightfield. This closest intersection is what part of the heightfield is truly visible. Relief mapping and parallax occlusion mapping are other common names for these techniques.

Interval mapping improves on the usual binary search done in relief mapping by creating a line between known inside and outside points and choosing the next sample point by intersecting this line with a ray, rather than using the midpoint as in a traditional binary search.

References

[edit]

^ Kaneko, T., et al., 2001. Detailed Shape Representation with Parallax Mapping Archived 2016-06-01 at the Wayback Machine. In Proceedings of ICAT 2001, pp. 205-208.
^ Tatarchuk, N., 2005. Practical Dynamic Parallax Occlusion Mapping Archived 2009-09-25 at the Wayback Machine Siggraph presentations

External links

[edit]

Comparison from the Irrlicht Engine: With Parallax mapping vs. Without Parallax mapping
Parallax mapping implementation in DirectX, forum topic
Parallax Mapped Bullet Holes - Details the algorithm used for F.E.A.R. style bullet holes.

v t e Texture mapping techniques
Local	Displacement mapping Normal mapping Parallax mapping UV mapping UVW mapping Relief mapping Alpha mapping Bump mapping Occlusion mapping Specular mapping
Environment	Cube mapping Sphere mapping Environment mapping

Revisions and contributors Edit on Wikipedia Read on Wikipedia

View on Grokipedia

from Grokipedia

Parallax mapping is a computer graphics technique that enhances the visual depth of textured surfaces on flat polygons by dynamically offsetting texture coordinates based on a height map and the viewer's direction, simulating motion parallax to create the illusion of three-dimensional geometry without requiring additional vertices or tessellation.^[1] Introduced by Tomomichi Kaneko and colleagues in 2001, it builds upon normal mapping by incorporating height information to adjust per-pixel sampling, allowing for real-time rendering of detailed surfaces such as rough stone or fabric on consumer hardware.^[1] The method typically operates in the fragment shader, where the view direction in tangent space is scaled by a height value from the map to shift coordinates, often using a simple linear approximation like

u' = u + \tan(\theta) \cdot \text{depth}(u,v)

, where

\theta

is the angle relative to the surface normal.^[2] While effective for smooth height fields and low computational cost—adding only a few shader instructions—parallax mapping can produce artifacts at steep viewing angles or with abrupt height changes, as it does not account for self-occlusions or intersections.^[2] To address these limitations, extensions such as steep parallax mapping, which employs multiple height samples along a ray, and parallax occlusion mapping (POM), introduced by Natalya Tatarchuk in 2006, incorporate ray marching through the height field for more accurate depth and shadow simulation.^[3] POM, in particular, enables perspective-correct parallax, soft self-shadowing, and adaptive level-of-detail for dynamic scenes, achieving high frame rates (e.g., over 100 fps on early 2000s GPUs) while supporting complex lighting models.^[3] These techniques remain widely used in real-time applications like video games and virtual reality for efficient surface detailing.^[4]

Introduction

Definition

Parallax mapping is a real-time computer graphics technique that extends traditional bump or normal mapping by simulating the geometric depth and motion parallax of uneven surfaces on a flat polygonal mesh. It achieves this by perturbing texture coordinates per pixel according to the viewer's angle and a provided height field, thereby creating a view-dependent illusion of raised or recessed details without requiring additional vertices or tessellation. Introduced as a method for detailed shape representation, it leverages per-pixel processing to enhance surface realism in rendering pipelines.^[1] At its core, parallax mapping employs a grayscale height map—a texture where each texel's intensity encodes relative surface depth—to determine the displacement magnitude for adjacent texture samples. This offset mimics the shifting appearance of surface features as the viewpoint changes, providing depth cues such as motion parallax that normal mapping alone cannot convey. The technique operates entirely in the fragment shader, preserving the efficiency of texture-based rendering while adding perceptual depth to low-polygon models, such as bricks or terrain.^[1]^[5] The mathematical foundation relies on projecting the view direction onto the texture plane to compute the offset. In tangent space, the offset vector is derived as

\vec{P} = \frac{\vec{V}_{xy}}{\vec{V}_z} \times (h \times s),

xy×(h×s), where $\vec{V}$

is the normalized view direction, $h$ is the height value sampled from the height map (typically in [0,1]), and $s$ is a scaling factor to control exaggeration. The final texture coordinates are then adjusted by subtracting $\vec{P}$

, enabling the renderer to sample displaced positions that simulate surface protrusion. This linear approximation provides a computationally efficient basis for the effect, though it assumes small displacements for accuracy.^[6]

Purpose and benefits

Parallax mapping serves as a technique to impart perceived depth to otherwise flat textured surfaces in real-time rendering applications, such as video games, enhancing visual realism while maintaining low geometric complexity. By manipulating texture coordinates based on the viewer's perspective, it simulates the appearance of uneven surfaces without requiring additional polygons, allowing developers to achieve detailed visuals on modest hardware configurations. This approach addresses the limitations of basic texture mapping, which cannot convey motion parallax effects essential for immersive environments.^[1] One key benefit is the enhanced sense of immersion through the simulation of parallax shift, where elements perceived as closer in the texture move more rapidly across the screen compared to those farther away as the camera shifts. This view-dependent distortion creates a convincing illusion of three-dimensionality, complementing techniques like normal mapping to produce highly realistic results at interactive frame rates. As a cost-effective alternative to geometric displacement methods, which demand significantly higher vertex counts and computational overhead, parallax mapping enables detailed surface representation using per-pixel operations that leverage graphics hardware acceleration. It remains compatible with modern GPUs, supporting efficient implementation in resource-constrained scenarios without substantial performance penalties.^[1]^[4]^[7] A practical example of its application is on environmental elements like walls or floors, where parallax mapping can make brick patterns or cobblestone textures appear raised or recessed, adding subtle depth that enriches scene detail without altering the underlying mesh topology. This technique relies on height maps to determine the offset for texture sampling, ensuring the effect aligns with surface geometry.^[4]

History

Early developments in surface mapping

Bump mapping was introduced by James F. Blinn in 1978 as a technique to simulate the appearance of wrinkled or rough surfaces in computer-generated images. In his seminal paper "Simulation of Wrinkled Surfaces," Blinn described a method that perturbs the surface normals based on a scalar height field derived from a 2D grayscale texture, allowing shading calculations to mimic small-scale geometric details without altering the underlying polygon mesh. This approach significantly enhanced visual realism in early computer graphics applications, such as those in film and scientific visualization, by enabling efficient computation of lighting effects like shadows and highlights on flat surfaces.^[8] During the 1990s, bump mapping evolved into more sophisticated forms, culminating in normal mapping, which stores precomputed normal vectors directly in RGB textures to achieve greater accuracy in lighting simulations. Unlike traditional bump mapping, which derives normals on-the-fly from height values, normal mapping uses the texture's color channels to encode the x, y, and z components of the normal vector in tangent space, facilitating per-pixel lighting computations on low-polygon models. This advancement was driven by improvements in graphics hardware and algorithms, making it feasible for real-time applications in video games and interactive simulations. A pivotal contribution came from Mark S. Peercy, John M. Airey, and Brian Cabral in their 1997 SIGGRAPH paper "Efficient Bump Mapping Hardware," which outlined hardware-accelerated methods for per-pixel normal perturbations, reducing computational overhead while maintaining high-quality shading. A key milestone in this progression was the shift from 2D grayscale bump maps, which primarily encoded height information, to vector-based normal maps that explicitly represent directional normal variations. This transition, building on earlier generalizations like James T. Kajiya's 1985 work on anisotropic reflection models that extended bump mapping to perturb both normals and tangent frames, enabled more precise control over surface appearance and paved the way for per-pixel lighting in real-time rendering pipelines. By the early 2000s, normal mapping had become a standard tool for enhancing detail on low-poly geometry, laying the groundwork for depth illusion techniques like parallax mapping.^[9]

Introduction of parallax mapping

Parallax mapping was first described in 2001 by Tomomichi Kaneko and colleagues in their paper "Detailed Shape Representation with Parallax Mapping," presented at the International Conference on Artificial Reality and Telexistence (ICAT) 2001. The technique introduced a simple offset-based approach to simulate motion parallax effects on height fields using per-pixel texture coordinate adjustments on a single polygon surface, enabling efficient representation of detailed shapes in real-time rendering. This method provided a per-pixel level of detail without requiring additional geometry, making it suitable for hardware-accelerated graphics.^[1] The technique experienced rapid adoption in the early 2000s, coinciding with GPU advancements such as the release of shader model 2.0 in 2002 under DirectX 9, which supported programmable per-pixel shading necessary for parallax computations. Building directly on bump and normal mapping foundations, parallax mapping enhanced surface realism by incorporating view-dependent depth illusions. It appeared in video games like F.E.A.R. (2005) and Tom Clancy's Splinter Cell: Chaos Theory (2005), where it was used to add dynamic depth to textures such as walls and floors, improving visual fidelity without substantial performance overhead. The initial simple offset method, which approximated surface irregularities through linear texture shifts, was quickly expanded to better handle steeper viewing angles and reduce artifacts like distortion at oblique views. This evolution, exemplified by offset limiting techniques introduced in 2004, solidified parallax mapping's role in real-time rendering pipelines, paving the way for more advanced variants in subsequent graphics hardware generations.

Fundamental principles

Height maps and texture offsetting

In parallax mapping, the height map serves as a grayscale texture that encodes surface elevation information, where each pixel's intensity value ranges from 0 (representing the highest point, such as protrusions) to 1 (representing the lowest point, such as valleys) to indicate relative depth at that texel, often using an inverse height map or depth map convention for intuitive displacement.^[4] This single-channel texture provides the essential input for approximating geometric details on flat or low-polygon surfaces without requiring additional vertex modifications.^[10] Height maps are typically generated through artistic creation in digital tools, derived from 3D scans of physical objects to capture real-world irregularities, or approximated from existing normal maps by integrating the implied slopes across neighboring pixels.^[4] The core texture offsetting process begins by sampling the height map at the current fragment's original texture coordinates to retrieve the height value. This height is then scaled by a user-defined parameter, known as height_scale, which adjusts the overall magnitude of the displacement effect to suit the desired visual depth. The offset is calculated within the tangent space of the surface, ensuring alignment with the local geometry, and incorporates the view direction to simulate perspective-correct shifting of the texture coordinates.^[6] The basic offset formula, as derived in standard implementations of parallax mapping, is given by: \text{texCoord} = \text{originalTexCoord} - \left( \frac{\text{viewDir}_{xy}}{\text{viewDir}_z} \times \text{height} \times \text{height_scale} \right) where

\text{viewDir}

denotes the normalized view direction vector transformed into tangent space, with its

xy

components providing the lateral shift and the

z

component normalizing for depth.^[6] This computation, introduced in the seminal work on parallax mapping, enables efficient per-pixel adjustments that produce subtle view-dependent parallax shifts.^[10]

View-dependent displacement

View-dependent displacement in parallax mapping simulates depth by dynamically offsetting texture coordinates based on the viewer's perspective, particularly the angle between the surface normal and the view direction. This adjustment mimics real-world parallax, where foreground elements appear to shift relative to the background as the observer moves, effectively allowing closer features encoded in the height map to occlude distant ones during rendering. The offset is scaled by the height value from the height map, ensuring that taller protrusions cause greater shifts in sampling positions to represent occlusion more accurately.^[10] To enable precise per-fragment computations, the view vector—originating from the eye position to the surface point—is transformed into tangent space using the tangent-bitangent-normal (TBN) matrix. This matrix, constructed from the surface's tangent, bitangent, and normal vectors, aligns the view direction with the local texture coordinate system, allowing offsets to be applied directly in the UV space of the height and color textures. By performing this transformation in the fragment shader, parallax mapping achieves consistent displacement across the surface without relying on vertex-level approximations.^[3] A core aspect of this approach is the amplification of parallax shift at grazing angles, where the view direction approaches parallelism with the surface plane, resulting in larger offsets that heighten the depth perception similar to human vision under oblique viewing conditions. However, such extreme angles can introduce artifacts like texture swimming or unnatural stretching; to mitigate these, offset clamping limits the maximum displacement to the sampled height value, preventing over-extension and maintaining visual stability.^[2]^[11]

Variants

Basic parallax mapping

Basic parallax mapping, also known as offset mapping, is a technique that simulates surface depth by applying a single linear offset to texture coordinates based on a height map value and the view direction.^[10]^[2] This method relies on the fundamental principles of height offsetting and view dependence to create a parallax effect without requiring additional geometry.^[10] The algorithm proceeds in four main steps, all performed per fragment in a shader. First, the view direction from the fragment to the camera is transformed into tangent space using the tangent-bitangent-normal (TBN) matrix, yielding a vector

\mathbf{V}

where the z-component approximates the cosine of the angle to the surface normal.^[4]^[10] Second, the height map—a grayscale texture representing surface depths normalized between 0 and 1—is sampled at the original texture coordinates

(\mathbf{u}, \mathbf{v})

to obtain a scalar height value

h

.^[2] Third, an offset vector

\mathbf{p}

is computed as

\mathbf{p} = \frac{\mathbf{V}_{xy}}{\mathbf{V}_z} \cdot (h \cdot s)

, where

s

is a user-defined height scale factor that controls the effect's intensity; this approximates the lateral shift proportional to the tangent of the view angle and height.^[4]^[10] Finally, the adjusted coordinates

\mathbf{u}' = (\mathbf{u}, \mathbf{v}) - \mathbf{p}

are used to re-sample the color (diffuse) and normal textures, providing the illusion of depth while maintaining compatibility with normal mapping for lighting.^[2]^[4] This linear interpolation assumes a flat height field and performs a single offset without considering self-occlusion, making it computationally efficient but prone to distortions on steep surfaces or areas with rapid height variations, where the approximation fails to accurately represent the true intersection with the height field.^[10]^[2] As a result, it is best suited for shallow relief surfaces like bricks or terrain with moderate undulations.^[4]

Steep parallax mapping

Steep parallax mapping, introduced by Morgan McGuire and Max McGuire in 2005 as a poster at the Symposium on Interactive 3D Graphics and Games, extends basic parallax mapping to better handle surfaces with steep angles where single-step offsetting fails to maintain geometric illusions.^[12] This technique addresses limitations in earlier parallax methods by incorporating iterative ray stepping, enabling more accurate approximation of view-ray intersections with height fields and reducing distortions at grazing view angles.^[13] The core of steep parallax mapping involves marching a ray through a series of discrete depth planes in texture space, using a fixed number of linear steps—typically 5 to 60 iterations depending on the view angle—to find the first intersection point with the height field encoded in the bump map's alpha channel.^[12] In the process, the algorithm starts from the surface point and increments texture coordinates along the projected view direction scaled by the bump height and view angle, while simultaneously decrementing a current depth value; it terminates at the step where the sampled height from the map exceeds the accumulated depth, selecting that point for shading.^[13] This linear stepping approach, implemented efficiently in pixel shaders, avoids the need for binary search and leverages MIP-mapping for anti-aliasing, allowing real-time performance at resolutions like 1024x768 with 30 frames per second and 4x full-scene anti-aliasing on contemporary hardware.^[12] By performing multiple steps rather than a single offset, steep parallax mapping preserves the depth illusion on inclined or high-frequency surfaces, such as rocky terrains or fabric weaves, without requiring additional geometry or 3D textures, though it may still exhibit aliasing on very thin features.^[13]

Parallax occlusion mapping

Parallax occlusion mapping (POM) is an advanced variant of parallax mapping that incorporates raymarching along the view direction in screen space to accurately determine intersection points with a height map, thereby enabling realistic self-shadowing and occlusion effects on displaced surfaces.^[14] This technique simulates the occlusion of surface details by tracing rays from the fragment position toward the viewer, sampling the height map iteratively to find where the ray first intersects the virtual geometry defined by the height field.^[15] By resolving these intersections, POM provides perspective-correct displacement and handles visibility blocking, improving upon simpler parallax methods by accounting for depth-aware shadowing without requiring actual geometry tessellation.^[14] The algorithm begins by initializing a ray at the fragment's texture coordinate with an initial depth of 0, aligned in the tangent space along the parallax offset vector derived from the view direction.^[15] It then performs iterative raymarching: the UV coordinates are offset in the direction opposite to the view (toward the eye), and the accumulated depth is incremented by a step size. At each iteration, the height map is sampled at the current UV position; the march stops at the first point where the sampled height exceeds the current ray depth, indicating an occlusion or intersection.^[14] This process approximates the ray-height field intersection linearly, with the final UV used for texturing and the intersection depth for subsequent shading calculations.^[15] To enable self-shadowing, a secondary raymarch is conducted from the determined intersection point along the light direction, again sampling the height map to check for blocking geometry; if any sample height exceeds the light ray's accumulated depth, the fragment is considered occluded and shaded accordingly.^[14] The core ray stepping can be expressed in pseudocode as follows:

currentDepth = 0.0; stepSize = 1.0 / numSteps; currentUV = initialUV; for (int i = 0; i < numSteps; i++) { currentUV -= parallaxDirection * stepSize; float heightSample = sampleHeight(currentUV); currentDepth += stepSize; if (heightSample > currentDepth) { // Intersection found; refine or use for occlusion break; } }

^[15] POM extends steep parallax mapping by integrating full occlusion handling through this raymarching approach, often refining the linear search with binary subdivision for greater precision and efficiency in locating intersections.^[14] This variant has become common in modern real-time rendering engines, including Unity and Unreal Engine, where it has been supported since the 2010s for enhancing material details in games and simulations.^[16]^[17]

Bump and normal mapping

Bump mapping is a technique that simulates surface irregularities by perturbing the surface normals derived from a height map, thereby altering lighting calculations to create the illusion of depth without modifying the underlying geometry.^[18] Introduced by James F. Blinn in 1978, it uses a texturing function to apply small perturbations to the normal vectors at each point on a parametrically defined surface, enabling realistic shading of wrinkles or bumps while keeping the polygon count low.^[18] This method produces a static visual effect that depends solely on the light direction and surface orientation, with no shift in texture coordinates or view-dependent displacement, resulting in an illusion that breaks down at grazing angles where the lack of actual depth becomes apparent.^[18] Normal mapping extends bump mapping by storing explicit normal vectors in a texture map, typically in tangent space, to provide more precise control over per-fragment lighting for simulating fine surface details like grooves or scratches.^[19] Developed as an efficient hardware implementation in the late 1990s, it encodes the x, y, and z components of perturbed normals as RGB color values, allowing dynamic interaction with light sources without geometric alterations.^[19] Like bump mapping, normal mapping creates a flat appearance from oblique viewing angles because it only affects shading and does not incorporate depth-based parallax or coordinate offsetting.^[19] In contrast to parallax mapping, both bump and normal mapping lack horizontal texture displacement based on the viewer's perspective, which limits their ability to convey raised or sunken surfaces as the camera moves; parallax mapping addresses this by introducing view-dependent offsets that enhance the perceived depth and motion parallax on uneven terrains.^[1] Parallax mapping often integrates with normal mapping to combine accurate lighting perturbations with displacement effects for more convincing surface detail.^[1]

Displacement mapping

Displacement mapping is a computer graphics technique that modifies the actual geometry of a surface by displacing vertices based on values from a height map, thereby creating tangible three-dimensional detail rather than simulating it through shading alone.^[20] This process typically involves subdividing the base mesh to increase polygon density, allowing for precise application of displacements perpendicular to the surface normal.^[21] In modern real-time rendering pipelines, such as those using DirectX 11 and later, displacement mapping is often implemented via hardware-accelerated tessellation shaders, which dynamically generate additional vertices during rendering to support these geometric changes.^[22] Unlike parallax mapping, which relies on screen-space texture offsetting to create an illusion of depth without altering geometry, displacement mapping produces authentic surface variations that correctly interact with light, including accurate silhouettes, self-occlusions, and shadows.^[20] This geometric fidelity comes at a higher computational cost, as it requires mesh subdivision and increased vertex processing, making it less suitable for performance-critical scenarios compared to the lighter, approximate effects of parallax mapping.^[23] Originally introduced in 1984 as part of procedural shading systems, displacement mapping evolved significantly in the 2000s with the advent of programmable GPUs and hardware tessellation, enabling its use in both offline rendering for films—where it adds intricate details like wrinkles or terrain features without manual modeling—and selective real-time applications in games for high-fidelity assets. Like parallax mapping, it utilizes a height map as input to define displacement amounts, but applies these to actual polygons for verifiable geometric accuracy.^[2]

Implementation aspects

Shader integration

Parallax mapping is typically integrated into the rendering pipeline through programmable shaders, primarily leveraging the vertex and fragment stages in graphics APIs such as OpenGL or DirectX. In the vertex shader, the tangent-bitangent-normal (TBN) matrix is computed to transform vectors into tangent space, which is essential for aligning the height map's displacement with the surface geometry. This matrix is derived from the model's per-vertex attributes—including positions, normals, tangents, and bitangents—and passed as an interpolated varying to the fragment shader. The fragment shader then utilizes this TBN matrix to convert the view direction from world or eye space into tangent space, enabling per-pixel texture coordinate offsets based on the height map. This setup allows for the resampling of diffuse and normal textures at displaced UV coordinates, enhancing surface depth without modifying the underlying geometry.^[4]^[10] The integration process involves several key steps to ensure accurate displacement. First, height and normal maps are loaded as textures and bound as uniforms in the shader program, often alongside a scaling factor to control the parallax intensity. Second, the view vector is transformed into tangent space using the TBN matrix, typically by taking the difference between the eye position and fragment position, normalizing it, and multiplying by the inverse TBN. Third, the chosen variant's algorithm—such as linear offsetting for basic parallax or binary search refinement for occlusion mapping—is applied to compute the offset, where the view direction's XY components are scaled by the sampled height value divided by the Z component to simulate ray intersection with the virtual surface. Finally, the modified UV coordinates are used to sample the material textures, with the resulting normals fed into the lighting calculations for the final fragment color. These steps build on foundational height offsetting and view-dependent displacement by executing them in a per-fragment manner for real-time performance.^[12]^[15]^[4] A basic implementation of parallax mapping in GLSL can be illustrated with the following pseudocode snippet in the fragment shader, focusing on the linear offset variant:

glsl

uniform sampler2D [heightMap](/page/Heightmap); uniform sampler2D normalMap; uniform sampler2D diffuseMap; [uniform](/page/Uniform) float heightScale = 0.05; in mat3 TBN; in vec3 FragPos; in vec2 TexCoords; in vec3 ViewPos; // Passed from vertex shader or [uniform](/page/Uniform) vec2 ParallaxOffset(vec2 texCoords, vec3 viewDir) { float height = texture([heightMap](/page/Heightmap), texCoords).r; vec2 p = viewDir.xy / viewDir.z * (height * heightScale); return texCoords - p; } void main() { // Transform view direction to tangent space vec3 viewDir = normalize(ViewPos - FragPos); viewDir = TBN * viewDir; // Calculate offset vec2 offsetTexCoords = ParallaxOffset(TexCoords, viewDir); // Sample normal map with offset vec3 normal = texture(normalMap, offsetTexCoords).rgb; normal = normalize(TBN * normalize(normal * 2.0 - 1.0)); // Sample diffuse map with offset vec3 diffuse = texture(diffuseMap, offsetTexCoords).rgb; // Proceed with lighting using offset normal and diffuse // ... }

This example declares uniforms for the height scale and texture maps, computes the offset in tangent space, and applies it to texture sampling before lighting. For variants like steep or occlusion mapping, the offset function would incorporate iterative ray marching or binary search to handle steeper surfaces and self-occlusion.^[4]^[12]

Performance optimization

Parallax mapping, particularly its more advanced variants like steep parallax and parallax occlusion mapping (POM), can be computationally intensive due to the iterative ray-heightfield intersection process performed per fragment. To optimize performance in real-time rendering, one key technique involves reducing the number of iterations in the ray marching loop. For instance, POM implementations often employ dynamic flow control to adjust the sample count based on the viewing angle, typically ranging from a minimum of 8 to a maximum of 50 samples, which minimizes unnecessary computations for near-perpendicular views while maintaining quality for grazing angles.^[14] Adaptive step sizing further enhances efficiency by scaling the step distance dynamically according to the view angle and heightfield resolution, reducing aliasing and over-sampling without fixed uniform steps. This approach, integral to practical POM deployments, allows for higher frame rates by tailoring the precision to the geometric context.^[14] For distant surfaces, level-of-detail (LOD) strategies using mipmapped heightfields enable coarser sampling at lower resolutions, as demonstrated in pyramidal displacement mapping techniques that traverse image pyramids to find intersections efficiently.^[24] Precomputing the tangent-bitangent-normal (TBN) matrix in the vertex shader, rather than per-fragment, amortizes the cost of tangent space transformations across interpolated attributes, a standard optimization applicable to all parallax variants.^[25] Hardware-wise, these methods perform best on GPUs supporting pixel shader model 3.0 or higher, where loop constructs and dynamic branching are efficient; earlier models like shader model 2.0 suffice for basic parallax but struggle with POM's iterations. Balancing fill rate is crucial, as uncullable fragments in POM can lead to significant overhead—for example, unoptimized POM on mid-range hardware like NVIDIA GeForce GTX 560Ti may increase per-frame rendering time from around 4 ms to over 6 ms in complex scenes, potentially halving frame rates without mitigation.^[25] A practical tip for further gains is combining parallax mapping with screen-space techniques, such as screen-space displacement mapping, to cull occluded fragments early and reduce overdraw on hidden surfaces. This hybrid approach leverages depth buffers to skip unnecessary ray marches, preserving visual fidelity while boosting throughput on fill-rate limited scenarios.^[26]

Applications and limitations

Use cases in graphics

Parallax mapping finds extensive application in video games, where it enhances the visual fidelity of environments by simulating depth on surfaces such as floors, walls, and terrain without requiring additional geometry, thereby maintaining performance in real-time rendering.^[7] In titles like Crysis (2007), developed using CryENGINE 2, parallax occlusion mapping (a variant) was employed to add intricate details to rocky terrains and building facades, contributing to the game's renowned graphical realism.^[27] Modern projects built on Unreal Engine, such as various open-world adventures, leverage parallax mapping to create immersive landscapes and architectural elements, often integrating it with normal mapping for enhanced surface irregularities.^[28] In architectural visualization, parallax mapping simulates material depth on complex surfaces like stucco walls or fabric drapery during real-time walkthroughs, allowing designers to convey realistic textures efficiently without high-polygon models.^[7] Tools such as wParallax provide specialized texture maps for generating fake 3D interiors in building exteriors, streamlining the creation of detailed urban scenes in software like D5 Render.^[29] This approach is particularly valuable for interactive presentations, where it balances visual accuracy with computational demands.^[30] Beyond these domains, parallax mapping supports immersive experiences in virtual reality (VR) and augmented reality (AR) by adding depth to surfaces viewed from multiple angles, heightening the sense of presence in simulated environments.^[7] In mobile games developed with engines like Unreal Engine, simplified variants such as offset bump mapping (also known as parallax mapping in Unreal) are utilized to approximate depth on resource-constrained devices, optimizing battery life while preserving detail on elements like pavement or foliage.^[31] As of 2025, parallax mapping continues to be employed in ongoing projects such as Star Citizen for rendering detailed planetary surfaces and in tools like Blender add-ons for material creation.^[32]^[33] These applications demonstrate parallax mapping's versatility in delivering high-fidelity graphics across diverse platforms.^[3]

Drawbacks and artifacts

Parallax mapping techniques, including both basic variants and advanced forms like parallax occlusion mapping (POM), introduce several visual artifacts that can compromise rendering quality. One prominent issue is texture "swimming," where repeated texture sampling during viewpoint movement causes unnatural shimmering or shifting effects, particularly noticeable at oblique viewing angles due to inaccuracies in offset calculations.^[1]^[25] This artifact arises from the method's reliance on approximate depth offsets without true ray tracing, leading to aliasing in high-frequency height fields when sampling rates are insufficient.^[15] Incorrect self-shadowing is another common limitation in basic parallax mapping implementations, as the technique often fails to accurately compute occlusions between displaced surface elements, resulting in implausible shadow placements or missing contact shadows on detailed geometries.^[25]^[15] On very steep or curved surfaces, parallax mapping breaks down, producing distortions such as excessive flattening or stair-stepping artifacts at grazing angles, stemming from assumptions of smooth curvature and small angles between the surface normal and viewer direction.^[1]^[15] These failures are exacerbated by limited precision in height map representations, often limited to 8-bit depths, which cannot resolve fine details on complex topologies.^[15] Performance drawbacks further limit applicability, as the high shader complexity from iterative sampling—typically 8 to 50 steps per pixel—increases GPU load significantly, especially at oblique angles where more samples are needed for accuracy.^[25]^[15] This makes parallax mapping unsuitable for very low-end hardware, where multiple rendering passes may be required to meet precision needs under shader model constraints.^[15] Additionally, since no true geometry is generated, silhouette edges exhibit errors, with displaced pixels failing to align properly against the underlying mesh, leading to unnatural outlines.^[25] Advanced variants like POM mitigate some artifacts by incorporating ray-marching for better occlusion handling, reducing swimming and improving steep surface rendering compared to basic parallax mapping, though issues like aliasing in shadows and high sampling costs persist.^[25]^[15] These techniques are often layered with other methods, such as normal mapping, to balance detail and performance, but they remain approximations that contrast with more accurate yet computationally expensive approaches like displacement mapping.^[25]

History

Media collections

Parallax mapping

Recent from talks

Recent from talks

Contribute something

Contribute something

Media Pages

Timelines

Articles

Notes collections

Notes

Notes

Days in Chronicle

Parallax mapping

Steep parallax mapping

See also

References

External links