In third-person and top-down games, objects such as walls, trees, or environment props can sometimes block the camera’s view of the player.

This problem is known as camera occlusion. A common solution is Occlusion Fade, where objects between the camera and the player temporarily become transparent.

This technique is widely used in RPGs, strategy games, and open-world titles.

How Occlusion Fade Works

The system works by detecting objects between the camera and the player using a physics check such as a Raycast or SphereCast.

If an object blocks the view, its material transparency is gradually reduced so the player becomes visible again.

Detecting Blocking Objects

We cast a ray from the camera to the player to check if something is in the way.

using UnityEngine;

public class CameraOcclusion : MonoBehaviour
{
    public Transform player;
    public LayerMask occlusionLayers;

    void Update()
    {
        Ray ray = new Ray(transform.position, player.position - transform.position);
        RaycastHit hit;

        if (Physics.Raycast(ray, out hit, Mathf.Infinity, occlusionLayers))
        {
            Renderer renderer = hit.collider.GetComponent();

            if (renderer != null)
            {
                FadeObject(renderer);
            }
        }
    }

    void FadeObject(Renderer renderer)
    {
        Color color = renderer.material.color;
        color.a = 0.3f;
        renderer.material.color = color;
    }
}

Smooth Transparency Transition

Instantly changing transparency can feel unnatural. A better solution is to gradually fade objects using Lerp.

void FadeObject(Renderer renderer)
{
    Color color = renderer.material.color;
    color.a = Mathf.Lerp(color.a, 0.3f, Time.deltaTime * 5f);
    renderer.material.color = color;
}

This creates a smooth transition when objects become transparent.

Restoring Object Visibility

When the object is no longer blocking the camera, its opacity should return to normal.

void RestoreObject(Renderer renderer)
{
    Color color = renderer.material.color;
    color.a = Mathf.Lerp(color.a, 1f, Time.deltaTime * 5f);
    renderer.material.color = color;
}

Managing a list of currently faded objects helps restore them correctly.

Using SphereCast for Better Detection

Raycasts sometimes miss thin objects. Using SphereCast creates a wider detection area between the camera and player.

Physics.SphereCast(
    transform.position,
    0.5f,
    player.position - transform.position,
    out hit,
    Vector3.Distance(transform.position, player.position),
    occlusionLayers
);

This makes occlusion detection more reliable.

Shader-Based Transparency

In more advanced systems, developers modify transparency using shaders instead of changing the material color directly. This approach improves performance and allows smoother visual transitions.

Many modern games use a dedicated fade shader for occlusion handling.

Common Use Cases

• Trees fading in forest environments
• Walls fading in indoor scenes
• Buildings fading in top-down RPG games
• Large objects fading in open-world environments

Performance Tips

• Use LayerMasks to detect only environment objects.
• Avoid modifying shared materials directly.
• Cache renderers for better performance.
• Use SphereCast instead of multiple Raycasts.

Conclusion

Camera occlusion fade improves visibility and player experience in third-person and top-down games. By dynamically making blocking objects transparent, the camera can always maintain a clear view of the player.

This small feature significantly improves gameplay clarity and overall polish.