Overdraw occurs when multiple fragments are rendered to the same pixel during a frame, especially common with overlapping transparent objects. Since transparent surfaces require blending with existing framebuffer content, each additional layer increases GPU workload—potentially degrading performence significantly.

Common causes include excessive use of transparent shaders (e.g., "Transparent" or "Fade" variants), dense particle effects, and UI elements with alpha blending stacked in screen space. Unlike opaque geometry—which benefits from early depth testing—transparent objects are typically rendered back-to-front without depth write, forcing the GPU to process every fragment regardless of visibility.

To mitigate overdraw, consider the following strategies:

1. Minimize transparency: Replace transparent materials with opaque alternatives where visual fidelity permits. For example, use cutout shaders (AlphaTest) instead of full trnasparency when hard edges are acceptable.
2. Merge transparent meshes: Combine multiple small transparent objects into a single mesh to reduce draw calls and overlapping fragments.
3. Optimize particle systems: Reduce particle count, avoid unnecessary transparency, or use GPU instancing for better batching.
4. Use profiling tools: Leverage Unity’s Frame Debugger or RenderDoc to visualize overdraw hotspots.

Below is an improved approach to merging transparent meshes while preserving material assignments:

void MergeTransparentObjects()
{
    var transparentRenderers = FindObjectsOfType<MeshRenderer>()
        .Where(r => r.material.shader.name.Contains("Transparent"))
        .ToArray();

    if (transparentRenderers.Length == 0) return;

    var combineInstances = new List<CombineInstance>();
    var combinedMaterials = new List<Material>();

    foreach (var renderer in transparentRenderers)
    {
        var meshFilter = renderer.GetComponent<MeshFilter>();
        if (meshFilter?.sharedMesh == null) continue;

        var combine = new CombineInstance
        {
            mesh = meshFilter.sharedMesh,
            transform = renderer.transform.localToWorldMatrix
        };
        combineInstances.Add(combine);
        combinedMaterials.Add(renderer.sharedMaterial);

        renderer.enabled = false; // Disable original renderers
    }

    var mergedGO = new GameObject("Combined_Transparent");
    var mf = mergedGO.AddComponent<MeshFilter>();
    var mr = mergedGO.AddComponent<MeshRenderer>();

    mf.mesh = new Mesh();
    mf.mesh.CombineMeshes(combineInstances.ToArray(), true, true);
    mr.materials = combinedMaterials.Distinct().ToArray();
}

For replacing transparency with opaque shaders:

void ReplaceTransparentWithOpaque()
{
    var renderers = FindObjectsOfType<Renderer>();
    var opaqueShader = Shader.Find("Standard");

    foreach (var r in renderers)
    {
        if (r.material?.shader?.name.Contains("Transparent") == true)
        {
            r.material.shader = opaqueShader;
            // Optionally reset render queue
            r.material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Geometry;
        }
    }
}

Note that mesh combining only reduces overrdaw if the resulting geometry actually decreases pixel overlap—merging two large overlapping quads won’t help. Always validate optimizations with profiling data.