Fix Dynamic Light Flicker And Square Artifacts When Rotating Camera In Unity

Hey guys! Ever run into that super annoying issue in Unity where your dynamic lights start flickering like crazy or, even worse, get replaced by weird square artifacts when you rotate the camera? Yeah, it's a total buzzkill, especially when you're trying to create a polished and immersive experience. But don't worry, you're definitely not alone! This is a common problem, particularly in the Universal Render Pipeline (URP) and on platforms like Meta Quest, and there are several reasons why it might be happening. In this article, we'll break down the most common causes and, more importantly, how to fix them.

Understanding the Problem: Dynamic Lights and Rendering

So, what's the deal with dynamic lights and why do they sometimes act up? Well, dynamic lights are those that can move and change in real-time, casting shadows and illuminating your scene interactively. Think of a flickering torch, a moving car's headlights, or a spell being cast – all dynamic lighting scenarios. In contrast to baked lighting, which is pre-calculated and stored in lightmaps, dynamic lights are calculated every frame, making them more resource-intensive but also much more versatile.

The flickering and square artifacts you're seeing usually point to issues with how the rendering pipeline is handling these dynamic lights, especially when the camera moves. The rendering pipeline is essentially the engine's system for drawing everything you see on the screen. Unity offers different pipelines, with the URP being a popular choice for its performance and flexibility, especially on lower-powered devices like mobile phones and VR headsets such as the Meta Quest. However, the URP has its own set of quirks and settings that can impact dynamic lighting.

When you rotate the camera, the engine has to recalculate the lighting and shadows from the dynamic lights' perspective. This involves a bunch of complex math, and if things aren't set up correctly, you can end up with visual glitches like flickering or those dreaded square artifacts. To truly grasp why these problems occur, let's delve into the common culprits that lead to dynamic light flickering and square artifacts, allowing us to explore effective solutions.

Common Causes and Solutions

Alright, let's get down to the nitty-gritty. Here are the most frequent reasons why you might be experiencing these lighting issues, along with practical solutions you can try:

1. Shadow Distance and Quality Settings

One of the biggest factors influencing dynamic light rendering, particularly shadow casting, is the shadow distance. This setting determines how far away from the camera shadows will be rendered. If the shadow distance is too short, shadows might disappear abruptly as the camera moves, causing a flickering effect. Even worse, if the distance is extremely short, only a portion of the shadow map may be rendered, creating the appearance of square artifacts on your scene.

Solution:

• Increase Shadow Distance: Head over to your project's Quality Settings (Edit > Project Settings > Quality). Find the shadow distance setting and try increasing it. A higher value means shadows will be rendered further away, potentially eliminating the flickering. However, be mindful of performance – a very high value can impact frame rates, especially on lower-end devices. It's a balancing act!
• Adjust Shadow Quality: In the same Quality Settings panel, you'll also find options for shadow quality. Higher shadow resolution and more shadow cascades generally lead to smoother shadows and fewer artifacts. Experiment with different shadow resolution settings (Low, Medium, High, Very High) and cascade counts to find a good balance between quality and performance. The shadow cascades define how the shadow map is divided into sections based on distance from the camera, thus higher cascade counts can result in finer shadows and minimize artifacts in areas close to the camera.

Remember to test your changes thoroughly, especially in the target platform you're building for (e.g., Meta Quest). What looks good in the Unity editor might not translate perfectly to the device.

2. Pixel Light Count Limitations in Forward Rendering

If you're using the Forward Rendering Path in URP, you need to be aware of the Pixel Light Count setting. This setting limits the number of dynamic lights that can fully affect a single object. Lights exceeding the Pixel Light Count are rendered in a simpler, less accurate way, often without shadows. This limitation is intended to optimize performance, but it can lead to flickering if lights are constantly being added or removed from the list of lights affecting an object as the camera moves.

Solution:

• Increase Pixel Light Count: You can find the Pixel Light Count setting in your URP Renderer Data asset (Project window > Search for your URP Renderer Data). Try increasing the value to allow more lights to render fully. But again, be careful – a higher count means more calculations per frame, which can hurt performance. Evaluate the performance cost on your target device as you increase the pixel light count to ascertain the impact.
• Switch to Deferred Rendering (if possible): Deferred Rendering is an alternative rendering path that doesn't have the same Pixel Light Count limitation. It can handle a much larger number of dynamic lights without performance penalties, but it has its own trade-offs, such as increased memory usage. Switching to Deferred Rendering might resolve your flickering issue, but it's a significant change that could affect other aspects of your project. Before making the switch, carefully consider the performance implications and compatibility with your project's features.
• Light Prioritization and Culling: Instead of simply increasing the pixel light count, consider optimizing how your lights are prioritized and culled. Unity automatically prioritizes lights based on their intensity and distance from the camera. However, you can influence this process by adjusting light intensities and ranges. Additionally, ensure that you're using proper culling techniques (e.g., occlusion culling) to prevent lights that are not visible from being rendered. Smart management of light priorities and visibility can alleviate the load on your rendering pipeline and diminish the flickering caused by excessive light calculations.

3. Shadow Bias Issues

Shadow bias is a technique used to prevent shadow acne, a visual artifact where shadows appear to have a noisy, self-intersecting pattern. However, if the bias is set too high, shadows can become detached from the objects casting them, leading to a flickering effect, especially when the camera moves. On the other hand, too little bias can bring back the dreaded shadow acne.

Solution:

• Adjust Shadow Bias Settings: You can find shadow bias settings on individual light components. Experiment with the Bias, Normal Bias, and Near Plane values. The goal is to find a sweet spot where shadow acne is minimized, and shadows remain firmly attached to the objects. Typically, smaller values are better, but you'll need to tweak them based on your scene's scale and lighting setup. Understanding the effect of each bias parameter is critical: Bias adjusts the shadow's distance from the object surface, Normal Bias adjusts it based on the surface normal, and Near Plane controls the shadow's near clipping plane.
• Consider the Scene Scale: The scale of your scene can significantly impact shadow bias requirements. If your scene is very large, you might need slightly higher bias values. If it's very small, lower values are usually better. Ensuring that your scene is scaled appropriately can make the shadow bias adjustments more effective.

4. Shader Issues

Sometimes, the issue might not be with the lighting itself, but with the shaders used on your materials. Shaders are programs that determine how surfaces are rendered, and if they're not handling shadows correctly, you can get flickering or square artifacts.

Solution:

• Check Your Shaders: Make sure your shaders are compatible with the URP and that they're properly handling shadows. If you're using custom shaders, review the shadow pass and ensure it's set up correctly. Standard URP shaders generally handle shadows well, so if you're using custom shaders, compare their shadow implementation with the standard shaders.
• Use URP Lit Shader: If you're unsure, try using the standard URP Lit shader for your materials. This shader is designed to work seamlessly with URP lighting and shadows. It's a good baseline to test against, helping you isolate whether the issue lies in your shaders or elsewhere in your lighting setup.
• Shader Complexity: Overly complex shaders can also contribute to rendering issues, especially on lower-end devices. If your shaders involve extensive calculations or complex branching, consider optimizing them to reduce the processing load. Simplifying shader calculations or using alternative, less intensive methods can alleviate performance bottlenecks that lead to visual artifacts.

5. Platform-Specific Issues (e.g., Meta Quest)

If you're developing for a specific platform like the Meta Quest, there might be platform-specific settings or limitations that are causing the flickering. VR platforms often have very strict performance requirements, and lighting is a common area where compromises have to be made.

Solution:

• Optimize for the Platform: Consult the platform's documentation for recommended lighting settings and optimization techniques. The Meta Quest, for example, has specific recommendations for shadow distance, shadow resolution, and light count. Adhering to these guidelines can significantly improve performance and reduce visual artifacts.
• Use Single-Pass Rendering: Ensure you're using single-pass rendering if your platform supports it. Single-pass rendering reduces the number of draw calls required for stereo rendering in VR, which can improve performance and potentially reduce flickering related to shadow calculations. It renders both eyes in a single pass, thus optimizing the rendering process.
• Mobile Rendering Path: In the URP Renderer Data, there's a setting for the rendering path. For mobile VR platforms like the Meta Quest, the "Mobile" rendering path is often the most efficient. Ensure this setting is configured for the target platform, as it can influence lighting performance significantly.

6. Light Overlap and Intensity

Sometimes, the flickering isn't due to a technical issue but rather how the lights are placed and how intense they are. If you have multiple lights overlapping and casting shadows in the same area, the shadow calculations can become complex and lead to flickering.

Solution:

• Reduce Light Overlap: Try to minimize the number of lights overlapping and casting shadows in the same area. Rethink your lighting design and see if you can achieve the desired effect with fewer lights. Strategic light placement and avoiding excessive overlapping shadows can reduce rendering complexity.
• Adjust Light Intensities: Overly intense lights can exacerbate flickering issues. Experiment with reducing light intensities and see if it helps. Subtler lighting can often achieve the desired ambiance without pushing the rendering engine to its limits. You might also consider using indirect lighting techniques or baked lighting to complement the dynamic lights.

7. Scripting and Light Management

If you're dynamically creating or managing lights through scripts, errors in your code can lead to flickering. For instance, if you're rapidly enabling and disabling lights, or if you're constantly changing their properties every frame, you might introduce flickering.

Solution:

• Review Your Scripts: Carefully review the scripts that manage your lights. Look for any code that might be causing lights to rapidly change state or properties. Optimization of scripting logic can be crucial in minimizing flickering caused by dynamic light manipulations.
• Use Coroutines or InvokeRepeating: If you need to change light properties over time, consider using coroutines or InvokeRepeating instead of doing it every frame in the Update function. Coroutines allow you to spread the work over multiple frames, reducing the performance impact. InvokeRepeating can be used to schedule functions to run at specific intervals, making property adjustments more predictable and less jarring.
• Object Pooling: If you're frequently instantiating and destroying lights, consider using object pooling. Object pooling involves creating a pool of light objects at the start of the game and then reusing these objects as needed, rather than constantly creating and destroying them. This reduces the overhead associated with object instantiation and destruction, thus improving performance and reducing potential flickering.

Troubleshooting Steps

If you're still scratching your head, here's a systematic approach you can take to troubleshoot the issue:

1. Simplify the Scene: Start by disabling most of your lights and objects. Add them back one by one to see which ones are causing the problem.
2. Test Different Quality Settings: Try switching between different quality levels in your Quality Settings. This can help you identify if the issue is related to specific quality settings.
3. Profile Your Scene: Use the Unity Profiler to identify performance bottlenecks. This can help you pinpoint areas where your lighting setup is causing performance issues.
4. Check the Console: Look for any error messages or warnings in the Unity console. These might provide clues about the cause of the flickering.
5. Update Unity and URP: Make sure you're using the latest versions of Unity and URP. Sometimes, bugs are fixed in newer versions.

Conclusion

Flickering and square artifacts with dynamic lights can be a real headache, but with a systematic approach and an understanding of the underlying causes, you can usually track down the issue and fix it. Remember to consider shadow distance, pixel light count, shadow bias, shaders, platform-specific settings, light overlap, and scripting issues. And don't hesitate to simplify your scene and profile your performance to pinpoint the culprit. Happy lighting!