Разница в результате рендеринга для окна Game и в билде

using UnityEngine;
using UnityStandardAssets.Characters.ThirdPerson;
 
namespace ThisCamera.ViewCamera {
 
    //"излучатель", которым мы "щупаем" слои объектов в игре
    public class CameraSpherecaster : MonoBehaviour
    {
        private Layer[] layerPriorities = {                      //массив слоев (тип enum, определяется в скрипте Utility) (public! смотреть в инспекторе!)
        Layer.SeeThrough                                         //одинокий слой SeeThrough - объекты, которые должны делаться полупрозрачными
    };
 
        [SerializeField] float distanceToBackground = 100f;     //расстояние до условного фона
 
        private Camera viewCamera;                              //камера
 
        private Transform hitTarget, hitTargetCurr, hitTargetPrev;  //храним "куда попало", "нынешняя цель", "предыдущая цель"
 
        private bool transparency = true;                       //прозрачность (да/нет)
        
        private Transform shaderTargetTest = null;              //для дебага - трансформ, у которого проверяем colorAlpha
 
        ThirdPersonCharacter m_Character;                       //отсылка к компоненту "персонаж от третьего лица"
 
        RaycastHit m_hit;                                       //устанавливаем значение m_hit - куда попадаем                                     
 
        Layer m_layerHit;                                       //устанавливаем значение m_layerHit - слой, в который попали
 
        //начало игрового процесса
        void Start() // возможно, лучше через Awake()
        {
            viewCamera = Camera.main;                                                                           //инициализируем камеру
            m_Character = GameObject.FindGameObjectWithTag("Player").GetComponent<ThirdPersonCharacter>();      //получаем компонент "персонаж от третьего лица" - скрипт ThirdPersonCharacter
            hitTarget = null;                                                                                   //обнуляем "цели"
            hitTargetCurr = null;                                                                               //
            hitTargetPrev = null;                                                                               //
        }
 
        //Update() вызывается в каждом кадре
        void Update()
        {
            foreach (Layer layer in layerPriorities)               //для каждого слоя в массиве слоев
            {
                var hit = SpherecastForLayer(layer);               //проверяем, куда попала сфера
 
                if (hit.HasValue)                                  //если у данных о попадании есть значение 
                {
                    m_hit = hit.Value;                             //передаем наружу свойство "куда мы попали"
                    hitTarget = m_hit.transform;                   //берем трансформу и назначаем нашей целью (для удобства)
                    
                    if (hitTargetCurr != hitTarget)                 //если "актуальная цель" не тождественна тому, куда попала сфера
                    {
                        if (hitTargetPrev != null)                  //и если "предыдущая цель" не null
                        {
                            transparency = false;                   //то отключаем прозрачность
                            shaderTargetTest = shaderMagic(hitTargetPrev, transparency);    //работаем с "прыдыдущей целью" - возвращаем ей тип шейдера Opaque
                            hitTargetPrev = null;                                           //обнуляем "предыдущую цель"
                        }
 
                        hitTargetCurr = hitTarget;                  //в противном случае устанавливаем "актуальной целью" то, куда мы попали сферой
                        hitTargetPrev = hitTargetCurr;              //а в "предыдущей цели" - храним "актуальную"
                        transparency = true;                        //прозрачность - включаем
                    }
                }
                else
                {                                                   //если у "метателя сфер" нет попаданий
                    hitTargetCurr = hitTargetPrev;                  //назначаем "актуальной целью" - "предыдущую"
                    hitTargetPrev = null;                           //обнуляем "предыдущую цель"
 
                    if (hitTargetCurr != null)                      //если "актуальная цель" не null
                    {
                        transparency = false;                       //прозрачность отключаем
                    }
                }
            }
 
            shaderTargetTest = shaderMagic(hitTargetCurr, transparency);    //работаем с шейдером "актуальной цели"
 
        }
 
        void OnGUI()
        {
            if (shaderTargetTest != null)                       //для дебага - проверяем, хранятся ли данные об объекте, в который мы попали из "метателя сфер"
            {
                GUI.Box(new Rect(viewCamera.pixelWidth - 160, 10, 150, 100), "");
                GUI.Label(new Rect(viewCamera.pixelWidth - 130, 20, 130, 80), "colorAlpha = " + shaderTargetTest.GetComponent<Renderer>().material.color.a + 
                    "; RenderType = " + shaderTargetTest.GetComponent<Renderer>().material.GetTag("RenderType", true, "Nothing"));                              //получаем оттуда данные о типе рендерера и альфа-канале
            }
        }
 
        private Transform shaderMagic(Transform shaderTarget, bool isTransparent)               //функция, которая меняет свойства шейдера
        {
            if (shaderTarget != null)                                                           //если цель функции - не Null
            {
                Material shaderTargetMat = shaderTarget.GetComponent<Renderer>().material;      //находим материал
                Color shaderTargetColor = shaderTargetMat.color;                                //и его основной цвет             
 
                if (isTransparent)                                                                               //дальше все честно стырено из интернетов, но если нам нужен прозрачный шейдер
                {
                    shaderTargetMat.SetOverrideTag("RenderType", "Transparent");                                        //то мы меняем ему тип рендера
                    shaderTargetMat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);         //
                    shaderTargetMat.SetInt("_ZWrite", 0);                                                               //
                    shaderTargetMat.SetFloat("_Mode", 3);                                                               //режим рендера
                    shaderTargetMat.EnableKeyword("_ALPHAPREMULTIPLY_ON");                                              //
                    shaderTargetMat.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;                   //порядок рендера
                    shaderTargetColor.a = 0.1f;                                                                         //и величину альфа-канала основного цвета - (проблема в билде, не отображается!)
                }
                else
                {                                                                                                       //в противном случае откатываем все, как было
                    shaderTargetMat.SetOverrideTag("RenderType", "");                                                   //
                    shaderTargetMat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);                     //
                    shaderTargetMat.SetInt("_ZWrite", 1);                                                               //
                    shaderTargetMat.SetFloat("_Mode", 0);                                                               //
                    shaderTargetMat.DisableKeyword("_ALPHAPREMULTIPLY_ON");                                             //
                    shaderTargetMat.renderQueue = -1;                                                                   //
                    shaderTargetColor.a = 1.0f;                                                                         //
                }
 
                shaderTargetMat.color = shaderTargetColor;                                                              //назначаем материалу новый цвет
 
                return shaderTarget;                                                                                    //возвращаем для дебага цель попадания
            }
 
            return null;                                                                                                //или Null
        }
 
        RaycastHit? SpherecastForLayer(Layer layer)                                                                                 //функция, которая "тычет" raycast'ом в слои и находит в них точку попадания (RaycastHit? - тип может быть как RaycastHit, так и null)
        {
 
            int layerMask = 1 << (int)layer;                                                                                        //устанавливаем маску слоя (побитовое смещение на значение enum слоя)
            Vector3 origin = viewCamera.ScreenToWorldPoint(new Vector3(viewCamera.pixelWidth / 2.0f, viewCamera.pixelHeight / 2.0f, viewCamera.nearClipPlane));      //точка, из которой полетит сфера
            Vector3 direction = m_Character.transform.position - origin;                                                            //инициализируем виртуальный луч, который пойдет через центр экрана вниз
            origin = origin - direction * 0.5f;                                                                                     //смещаем точку за камеру, чтобы бить лучом издаля и избежать clipping plane
            RaycastHit hit;         // used as an out parameter                                                                     //информация о попадании луча во что-то
            bool hasHit = Physics.SphereCast(origin, 0.6f, direction, out hit, distanceToBackground, layerMask);                    //проверяем, попали ли мы во что-то нашим лучом, с учетом данных о максимальной длине луча (distanceToBackground) и маске слоя (layerMask)
 
            Debug.DrawRay(origin, direction, Color.red);                                    //рисуем луч из камеры в персонажа для дебага
 
            if (hasHit)                                                                     //если попали,
            {
                return hit;                                                                 //возвращаем значение, передаваемое по ссылке out hit            
            }
            return null;                                                                    //или null
        }
 
    }
 
}