Setting Optimal Clip Start And End Values To Reduce Z-Fighting In Blender

Definition of Z-Fighting

Z-fighting refers to the visual artifact that occurs when two or more surfaces in a 3D scene occupy essentially the same space, resulting in flickering as the faces rapidly swap which one is visible. It is caused by vertices sharing the same coordinate space, either exactly or within an imperceptibly small tolerance. The term comes from the fighting over which surface gets priority and is rendered in the final image.

Causes of Z-Fighting

Identical Location of Vertices

The most straightforward cause of z-fighting is when two or more vertices share the exact same 3D coordinates. This can occur when duplicate geometry overlaps or intersections are improperly handled. With coordinates precise to only a certain number of decimal places, Blender cannot reliably determine depth and flickering results as faces seemingly fight to be the closest.

Limited Floating Point Precision

While directly overlapping vertices is an obvious case, z-fighting can also occur when vertices are extremely close but not quite perfectly aligned. Most real-time 3D applications, including Blender, store coordinate positions using floating point values with fixed precision. This means there is a small degree of imprecision allowed, essentially defining a tolerance threshold. If vertices fall within this tolerance, flickering artifacts can still result even though the coordinates are not defined as identical.

Consequences of Z-Fighting

Flickering Artifacts

The most visually apparent consequence of z-fighting is flickering of the polygons as they rapidly swap which is visible. This results in a noisy, vibrating texture distortion distracting from the actual surface appearance. The faster the swap between faces, the more high frequency the flicker. Slower shifts can manifest as more gradual pulsing. Either way, this unstable rendering detracts from the scene quality.

Incorrect Shading

In addition to the distracting artifacts, z-fighting can also simply lead to incorrect shading of surfaces. Since depth is ambiguous, the wrong faces may be rendered or shadowing may flip inconsistently. This results in inaccurate lighting and reflections, contradicting the intent of the material definitions. For example, a surface meant to be fully illuminated could falsely fall into shadow if a fighting polygon wrongly wins priority.

Locating Problem Areas

Identifying areas of geometry susceptible to z-fighting is an important first step in addressing flickering artifacts.

Using Wireframe View

Enabling wireframe display allows seeing through surfaces to overlapping vertices and edges underneath. This visualization plainly revealsduplicate geometry nearly occupying the same space. Flickering during rendering likely aligns with wiring crossing in the wireframe view.

Analyzing Overlapping Geometry

In edit mode, carefully inspect areas where distinct surfaces intersect or come into close proximity. Model corners, boolean overlaps, and tight crevices are prone to vertex collisions either directly or through rounding imprecision. Select suspect vertices to check if they share coordinates or at least come imperceptibly close when numbers are rounded.

Fixing Z-Fighting

Once problematic areas have been identified, fixes can be applied to resolve the conflicts causing erratic artifacting.

Adjusting Clip Start and End

The camera clip start and end values define the visible depth range for rendering. Widening this range allows numerically close surfaces to separate and resolve priority since more precision is allocated. However, an excessively high clip end also reduces depth buffer precision for all surfaces so optimal values must be set.

Example Code for Changing Clipping

The following Python code snippet demonstrates dynamically adjusting clip start and end values on the active scene camera to reduce z-fighting:

“`python
import bpy
cam = bpy.context.scene.camera
cam.data.clip_start = 0.1
cam.data.clip_end = 1000
“`

Repositioning Problematic Vertices

Rather than masking issues by adjusting clip range, directly editing the geometry is a more robust approach. Select wrinkled vertices apparent during wireframe view and move them slight distances away from the intersection regions causing coordination collisions. This cleanly resolves the shared locations.

Increasing Floating Point Precision

As an advanced alternative to moving vertices, the floating point precision of the scene can be increased under the scene properties. This shrinks the tolerance threshold before coordinates are considered identical, allowing surfaces to come closer before z-fighting. However, significant precision jumps can noticeably slow rendering.

When to Accept Z-Fighting

While flickering artifacts are generally undesirable, some amount of z-fighting may be tolerable or even unavoidable in certain circumstances.

Minor Artifacting

If the visual disturbances from z-fighting are relatively minor and infrequent, the extra development effort to eliminate them may not be justified if overall scene quality remains high. As long as key surfaces and compositions are not significantly impacted, slight reflections or shadow distortions can potentially be excused.

Performance Considerations

Eliminating all z-fighting in extremely complex scenes with many interlocking details may require geometry modifications or precision increases that noticeably lower rendering performance. If frame rates cannot be sustained, allowing some artifacting can be a reasonable sacrifice. Since flakes only manifest under motion, they can be less noticeable at lower interactive speeds.