Unity Reflection Probe Flickering Bug: Causes and Reliable Fixes
You place a Reflection Probe in your scene. Shiny materials look great at first. Then you move the camera or the player walks through the environment, and reflections start flickering or popping between different lighting states.
This is commonly called the “Reflection Probe Flickering bug.” In most cases, Unity is not broken. The flicker usually comes from overlapping probes, incorrect update modes, or blending issues.
Here is how to diagnose and fix it properly.
Why Reflection Probes Flicker
Reflection Probes capture the surrounding environment into a cubemap. When multiple probes influence the same object, Unity blends them based on distance and importance.
Flickering happens when:
Two probes overlap too aggressively
Probe importance values are similar
Real-time probes update frequently
Objects rapidly move between probe volumes
Box projection is misconfigured
Step 1: Check Probe Overlap
Select your Reflection Probes and enable Gizmos in Scene View. Look at their influence volumes.
If two probes overlap heavily in the same area, objects inside that space may constantly switch blending weights.
Solution:
Reduce overlap area
Adjust box size carefully
Use fewer probes where possible
Step 2: Adjust Importance Values
Each Reflection Probe has an Importance value.
If two probes have equal importance and overlap, Unity blends them dynamically. This can cause visible popping.
Fix:
Give one probe higher importance
Use a clear hierarchy (e.g., interior probe higher than global probe)
Step 3: Avoid Frequent Real-Time Updates
If Reflection Probes are set to:
Refresh Mode → Every Frame
This can cause visible flicker, especially with moving lights or dynamic objects.
Better options:
Refresh Mode → On Awake
Refresh Mode → Via Scripting
Update only when necessary.
Step 4: Control Manual Probe Updates
If you need runtime updates, trigger them manually instead of every frame:
This gives you control over when the cubemap refreshes.
Step 5: Check Box Projection
Box Projection helps reflections look correct in interior spaces.
If enabled but probe bounds are incorrect, reflections may distort or flicker when the camera moves.
Make sure:
Box size matches room dimensions
Probe is centered correctly
Step 6: Check Object Anchor Override
Each Renderer has a setting called Anchor Override.
If not set correctly, reflections may calculate from an unstable position, especially for large objects.
Fix:
Create an empty GameObject at a stable position
Assign it as Anchor Override for reflective objects
Step 7: Watch for LOD Switching
If objects use LOD Groups, switching LOD levels can slightly alter reflection behavior, causing visible flicker.
Test by temporarily disabling LOD Groups to see if flickering stops.
Step 8: Pipeline-Specific Issues (URP/HDRP)
In URP or HDRP:
Ensure Reflection Probe blending is enabled in the pipeline asset
Check Screen Space Reflection settings
Avoid mixing SSR and probe reflections without proper tuning
Screen Space Reflections can override probe results, creating instability.
Common Symptoms
Reflections pop when moving between rooms
Metal surfaces flicker near doorways
Reflections change brightness rapidly
Works in Scene view but flickers in Game view
Quick Debug Checklist
Reduce probe overlap
Set clear importance hierarchy
Avoid “Every Frame” refresh mode
Adjust box projection bounds
Check Anchor Override on large objects
Verify pipeline reflection settings
Is This a Unity Bug?
True engine-level reflection probe flickering is rare. Most flickering is caused by blending conflicts, real-time refresh settings, or incorrect probe placement.
Reflection systems require careful layout planning, especially in interior environments.
Final Thoughts
Reflection Probe flickering is usually a configuration issue, not an engine failure. By organizing probe volumes properly, setting clear importance levels, and avoiding unnecessary real-time updates, reflections become stable and realistic.
Plan probe placement like lighting — thoughtfully and intentionally — and the flicker disappears.
![There’s something satisfying about watching a flat, boring plane turn into a mountain range. That’s exactly what a height map does in Unity. With a simple grayscale image, you can shape landscapes, add depth to materials, and create worlds that feel real instead of flat. It’s one of those tools that looks technical at first, but once you understand it, it becomes surprisingly simple and powerful. In this guide, we’ll break down what a height map is, how it works in Unity, how to use it for terrain, how it differs from normal maps, and how to control it with C#. What Is a Height Map? A height map is a grayscale image where each pixel represents elevation. Black = lowest height White = highest height Gray = values in between Think of it like a topographic map, but simplified into brightness levels. Unity reads this image and uses the brightness values to push parts of a surface up or down. The result? Hills, valleys, cliffs, and surface details created from a simple image. Height Maps in Unity Terrain The most common use of height maps in Unity is terrain generation. Unity’s Terrain system allows you to import a height map and automatically generate a 3D landscape from it. How to Import a Height Map into Terrain Create a Terrain: GameObject → 3D Object → Terrain Select the Terrain object. Open the Terrain Inspector. Choose Import Raw under the heightmap settings. Select your grayscale RAW file. Once imported, Unity converts the grayscale values into elevation data. If your height map is smooth, you’ll get rolling hills. If it has sharp contrast, you’ll get steep cliffs. Height Map Resolution Matters Resolution affects how detailed your terrain will be. A low-resolution height map creates blocky terrain. A high-resolution height map creates smoother, more detailed landscapes. However, higher resolution also increases memory usage and processing cost. If you're building for mobile, balance detail with performance. Height Maps vs Normal Maps This is where many beginners get confused. Height Map Actually changes geometry (in terrain or displacement). Creates real depth. More performance cost if geometry changes. Normal Map Does NOT change geometry. Fakes lighting to simulate bumps. Much cheaper performance-wise. If you need real terrain shape, use a height map. If you just want surface detail like cracks or scratches, a normal map is usually better. Using Height Maps in Materials (Parallax & Displacement) Height maps are not limited to terrain. You can also use them in materials. In Unity’s Standard Shader (or URP/HDRP equivalents), height maps can be used for: Parallax Mapping – creates depth illusion without changing geometry. Displacement Mapping – actually modifies mesh vertices (HDRP). For example, if you apply a brick texture, adding a height map can make the mortar appear recessed and bricks raised. Creating Height Maps You can create height maps using: Photoshop or GIMP (grayscale images) Blender (baked displacement maps) World Machine or Gaea (terrain generation tools) Procedural generation with code The key is keeping it grayscale and avoiding compression artifacts. Generating a Height Map with Code You can also generate terrain procedurally using Perlin Noise. This is common in open-world or survival games. Here’s a simple example: [csharp] using UnityEngine; public class TerrainGenerator : MonoBehaviour { public Terrain terrain; public int depth = 20; public int width = 256; public int height = 256; public float scale = 20f; void Start() { terrain.terrainData = GenerateTerrain(terrain.terrainData); } TerrainData GenerateTerrain(TerrainData terrainData) { terrainData.heightmapResolution = width + 1; terrainData.size = new Vector3(width, depth, height); terrainData.SetHeights(0, 0, GenerateHeights()); return terrainData; } float[,] GenerateHeights() { float[,] heights = new float[width, height]; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { heights[x, y] = Mathf.PerlinNoise(x / scale, y / scale); } } return heights; } } [/csharp] This script generates a terrain using Perlin Noise, which creates natural-looking hills and variation. Controlling Height Strength Sometimes height maps look too extreme. Other times they look flat. In terrain settings, you can adjust: Terrain height (Y scale) Brush strength (when sculpting manually) In materials, you can adjust height intensity inside the shader settings. Small adjustments make a big difference. Subtle depth often looks more realistic than exaggerated displacement. Common Problems and Fixes Terrain Looks Blocky Increase heightmap resolution or smooth the terrain. Edges Look Stretched Make sure your height map is square and uses proper dimensions (like 512x512 or 1024x1024). Lighting Looks Strange Check your normal settings and ensure lighting is baked or set correctly. When to Use Height Maps Use height maps when: You need large landscapes. You want realistic terrain shaping. You’re building procedural worlds. You need true geometric depth. Skip them when: You only need small surface detail. Performance is extremely limited. Final Thoughts Height maps are one of those tools that feel technical at first, but once you use them, they become creative tools. You’re not just editing numbers. You’re sculpting mountains. Carving valleys. Designing the shape of a world. Start simple. Import a grayscale image. Adjust the scale. Play with noise. Watch how small changes affect the landscape. Once you understand height maps, Unity stops feeling like a flat engine. It starts feeling like a world builder.](https://unityqueen.com/wp-content/uploads/2026/02/Lighting-in-Unity-150x150.jpg "Lighting in Unity: A Practical Guide for Game Developers")
