예제 #1
0
        bool IncludeSpotOrPointLight(Light light, GDOC_UpdateMode movementMode = GDOC_UpdateMode.Static, GDOC_Occludee parentOccludee = null)
        {
            var e = light.gameObject.AddComponent <GDOC_Occludee>();

            e.mode              = GDOC_OccludeeMode.Generic;
            e.movementMode      = movementMode;
            e.isTemporary       = true;
            e.isShadowSource    = light.shadows != LightShadows.None;
            e.disablePrediction = true;

            if (light.type == LightType.Point)
            {
                e.center  = Vector3.zero;
                e.extents = Vector3.one * light.range;
            }

            e.Init();

            if (light.type == LightType.Spot)
            {
                e.RecalculateContainerBounds();
            }

            return(AddOccludee(e, parentOccludee) != -1);
        }
예제 #2
0
        void Refresh()
        {
            updateMode = GDOC_UpdateMode.Static;

            for (var i = 0; i < chain.Count; i++)
            {
            }
        }
예제 #3
0
        bool IncludeMeshRenderer(Renderer renderer, GDOC_ManagementMode mode, GDOC_UpdateMode movementMode, GDOC_Occludee parentOccludee = null)
        {
            var meshFilter = renderer.GetComponent <MeshFilter>();

            if (meshFilter == null)
            {
                return(false);
            }

            if (meshFilter.sharedMesh == null)
            {
                return(false);
            }

            var e = renderer.gameObject.AddComponent <GDOC_Occludee>();

            e.mode              = GDOC_OccludeeMode.MeshRenderer;
            e.movementMode      = movementMode;
            e.isTemporary       = true;
            e.shadowCastingMode = renderer.shadowCastingMode;
            e.managementMode    = mode;

            e.Init();

            var size = e.size.x + e.size.y + e.size.z;

            if (size >= 3)
            {
                var material = renderer.sharedMaterial;

                if (material != null && material.shader != null)
                {
                    if (material.shader.renderQueue < 2450)
                    {
                        e.isImportant = true;
                    }
                }
            }

            return(AddOccludee(e, parentOccludee) != -1);
        }
예제 #4
0
        bool IncludeLODGroup(LODGroup lodGroup, GDOC_ManagementMode mode, GDOC_UpdateMode movementMode = GDOC_UpdateMode.Static, GDOC_Occludee parentOccludee = null)
        {
            var e = lodGroup.gameObject.AddComponent <GDOC_Occludee>();

            lodGroup.RecalculateBounds();

            e.mode           = GDOC_OccludeeMode.MeshRendererGroup;
            e.movementMode   = movementMode;
            e.isTemporary    = true;
            e.managementMode = mode;

            e.GrabLODGroupRenderers();

            e.Init();

            e.isImportant = e.volumeSizeSqr > 2;

            AddOccludee(e, parentOccludee);

            return(false);
        }
예제 #5
0
        bool IncludeReflectionProbe(ReflectionProbe probe, GDOC_UpdateMode movementMode = GDOC_UpdateMode.Static, GDOC_Occludee parentOccludee = null)
        {
            var e = probe.gameObject.AddComponent <GDOC_Occludee>();

            e.mode              = GDOC_OccludeeMode.Generic;
            e.movementMode      = movementMode;
            e.isTemporary       = true;
            e.center            = probe.center;
            e.extents           = probe.size * 0.5f;
            e.disablePrediction = true;
            // e.allowFullDisable = false;

            if (probe.mode == ReflectionProbeMode.Realtime && probe.refreshMode == ReflectionProbeRefreshMode.OnAwake)
            {
                probe.RenderProbe();
                probe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
            }

            e.Init();

            return(AddOccludee(e, parentOccludee) != -1);
        }
예제 #6
0
        bool IncludeParticleSystem(ParticleSystem ps, GDOC_UpdateMode movementMode = GDOC_UpdateMode.Static, GDOC_Occludee parentOccludee = null)
        {
            var main = ps.main;

            if (!main.loop)
            {
                return(false);
            }

            var e = ps.gameObject.AddComponent <GDOC_Occludee>();

            e.mode                  = GDOC_OccludeeMode.ParticleSystem;
            e.movementMode          = movementMode;
            e.dynamicUpdateInterval = 1;
            e.sizeMultiplier        = 1.1f;
            e.isTemporary           = true;

            e.Init();

            if (movementMode == GDOC_UpdateMode.Static)
            {
                var   lt       = main.startLifetime;
                float lifetime = 0;
                if (lt.mode == ParticleSystemCurveMode.Constant)
                {
                    lifetime = lt.constant;
                }
                else if (lt.mode == ParticleSystemCurveMode.Curve)
                {
                    lifetime = lt.curveMultiplier;
                }
                else if (lt.mode == ParticleSystemCurveMode.TwoConstants)
                {
                    lifetime = lt.constantMax;
                }
                else if (lt.mode == ParticleSystemCurveMode.TwoCurves)
                {
                    lifetime = lt.curveMultiplier; // hm
                }

                var t = main.duration + lifetime;

                var wasPlaying = ps.isPlaying;

                ps.Simulate(t);

                if (wasPlaying)
                {
                    ps.Play();
                }

                e.RecalculateContainerBounds(psOmnidirectionalBounds);

                if (e.size.magnitude < 1f && Application.isEditor)
                {
                    Debug.LogWarning(string.Format("Particle system {0} has very small static bounds", ps.name), ps.gameObject);
                }
            }

            return(AddOccludee(e, parentOccludee) != -1);
        }