protected void ProcessOcclusion(ProcessOcclusionSource source)
        {
            Debug.Assert(!Application.isPlaying || m_LastFrameRendered != Time.frameCount, "ProcessOcclusion has been called twice on the same frame, which is forbidden");
            Debug.Assert(m_Master);

            bool occlusionSuccess = OnProcessOcclusion(source);

            if (m_Master)
            {
                m_Master._INTERNAL_SetDynamicOcclusionCallback(GetShaderKeyword(), occlusionSuccess ? OnModifyMaterialCallback : (MaterialModifier.Callback)(null));
            }

            if (updateRate.HasFlag(DynamicOcclusionUpdateRate.OnBeamMove))
            {
                m_TransformPacked = transform.GetWorldPacked();
            }

            bool firstTime = m_LastFrameRendered < 0;

            m_LastFrameRendered = Time.frameCount;

            if (firstTime && _INTERNAL_ApplyRandomFrameOffset)
            {
                m_LastFrameRendered += Random.Range(0, waitXFrames); // add a random offset to prevent from updating texture for all beams having the same wait value
            }
        }
Esempio n. 2
0
        protected override bool OnProcessOcclusion(ProcessOcclusionSource source)
        {
            Debug.Assert(m_Master && m_DepthCamera);

            if (source == ProcessOcclusionSource.RenderLoop && SRPHelper.IsUsingCustomRenderPipeline()) // Recursive rendering is not supported on SRP
            {
                m_NeedToUpdateOcclusionNextFrame = true;
            }
            else
            {
                ProcessOcclusionInternal();
            }

            return(true);
        }
        protected override bool OnProcessOcclusion(ProcessOcclusionSource source)
        {
#if UNITY_EDITOR
            editorDebugData.lastFrameUpdate = Time.frameCount;
#endif
            var raycastGlobalForward = m_Master.raycastGlobalForward;
            var bestHit = GetBestHit(transform.position, raycastGlobalForward);

            if (IsHitValid(bestHit, raycastGlobalForward))
            {
                if (minSurfaceRatio > 0.5f)
                {
                    var raycastDistance = m_Master.raycastDistance;
                    for (uint i = 0; i < GetDirectionCount(); i++)
                    {
                        var dir3 = GetDirection(i + m_PrevNonSubHitDirectionId) * (minSurfaceRatio * 2 - 1);
                        dir3.Scale(transform.localScale);
                        var startPt = transform.position + dir3 * m_Master.coneRadiusStart;
                        var newPt   = transform.position + dir3 * m_Master.coneRadiusEnd + raycastGlobalForward * raycastDistance;

                        var bestHitSub = GetBestHit(startPt, (newPt - startPt).normalized);
                        if (IsHitValid(bestHitSub, raycastGlobalForward))
                        {
                            if (bestHitSub.distance > bestHit.distance)
                            {
                                bestHit = bestHitSub;
                            }
                        }
                        else
                        {
                            m_PrevNonSubHitDirectionId = i;
                            bestHit = null;
                            break;
                        }
                    }
                }
            }
            else
            {
                bestHit = null;
            }

            SetHit(bestHit);
            return(bestHit != null);
        }
        protected override bool OnProcessOcclusion(ProcessOcclusionSource source)
        {
#if UNITY_EDITOR
            editorDebugData.lastFrameUpdate = Time.frameCount;
#endif
            var bestHit = GetBestHit(transform.position, transform.forward);

            if (IsHitValid(bestHit))
            {
                if (minSurfaceRatio > 0.5f)
                {
                    for (uint i = 0; i < (uint)System.Enum.GetValues(typeof(Direction)).Length; i++)
                    {
                        var dir3    = GetDirection(i + m_PrevNonSubHitDirectionId);
                        var startPt = transform.position + dir3 * m_Master.coneRadiusStart * (minSurfaceRatio * 2 - 1);
                        var newPt   = transform.position + transform.forward * m_Master.fallOffEnd + dir3 * m_Master.coneRadiusEnd * (minSurfaceRatio * 2 - 1);

                        var bestHitSub = GetBestHit(startPt, newPt - startPt);
                        if (IsHitValid(bestHitSub))
                        {
                            if (bestHitSub.distance > bestHit.distance)
                            {
                                bestHit = bestHitSub;
                            }
                        }
                        else
                        {
                            m_PrevNonSubHitDirectionId = i;
                            bestHit = null;
                            break;
                        }
                    }
                }
            }
            else
            {
                bestHit = null;
            }

            SetHit(bestHit);
            return(bestHit != null);
        }
 protected abstract bool OnProcessOcclusion(ProcessOcclusionSource source);