Exemplo n.º 1
0
        private void DebugDraw()
        {
            if (((IMyUtilities)MyAPIUtilities.Static).IsDedicated)
            {
                return;
            }
            var cam = MyCameraComponent.ActiveCamera;

            if (cam == null)
            {
                return;
            }
            var proj = cam.GetProjectionSetup();

            proj.FarPlane = 100;
            var frust = new BoundingFrustumD(cam.GetViewMatrix() * proj.ProjectionMatrix);

            if (RailConstants.Debug.DrawGraphNodes)
            {
                Nodes.OverlapAllFrustum(ref frust, (Node node, bool intersects) =>
                {
                    var color = _nodeColor;
                    var p1    = node.Position;
                    var p2    = node.Position + _nodeMarkerSize * node.Up;
                    MySimpleObjectDraw.DrawLine(p1, p2, _squareMaterial, ref color, _nodeWidth);
                });
            }

            if (RailConstants.Debug.DrawGraphEdges)
            {
                Edges.OverlapAllFrustum(ref frust, (Edge edge, bool intersects) => { edge.Draw(0, 1, _edgeColor); });
            }
        }
Exemplo n.º 2
0
        public void DoWork(WorkData workData = null)
        {
            long Started = Stopwatch.GetTimestamp();

            ProfilerShort.Begin("DoCullWork");

            var frustum = m_query.Frustum;

            if (m_query.SmallObjects.HasValue)
            {
                if (MyRender11.Settings.DrawNonMergeInstanced)
                {
                    m_renderables.OverlapAllFrustum <MyCullProxy>(ref frustum, m_query.List, m_query.IsInsideList,
                                                                  m_query.SmallObjects.Value.ProjectionFactor, m_query.SmallObjects.Value.SkipThreshold,
                                                                  0, false);
                }

                if (MyRender11.Settings.DrawMergeInstanced)
                {
                    MyScene.GroupsDBVH.OverlapAllFrustum <MyCullProxy_2>(ref frustum, m_query.List2, m_query.IsInsideList2,
                                                                         m_query.SmallObjects.Value.ProjectionFactor, m_query.SmallObjects.Value.SkipThreshold,
                                                                         0, false);
                }
            }
            else
            {
                if (MyRender11.Settings.DrawNonMergeInstanced)
                {
                    m_renderables.OverlapAllFrustum <MyCullProxy>(ref frustum, m_query.List, m_query.IsInsideList, 0, false);
                }

                if (MyRender11.Settings.DrawMergeInstanced)
                {
                    MyScene.GroupsDBVH.OverlapAllFrustum <MyCullProxy_2>(ref frustum, m_query.List2, m_query.IsInsideList2, 0, false);
                }
            }

            ProfilerShort.End();
            Elapsed = Stopwatch.GetTimestamp() - Started;
        }
Exemplo n.º 3
0
        public void DoWork(WorkData workData = null)
        {
            var frustum = m_cpuFrustumCullPass.Frustum;

            if (MyRender11.Settings.DrawNonMergeInstanced)
            {
                m_renderables.OverlapAllFrustum <MyCpuCulledEntity>(ref frustum, m_cpuFrustumCullPass.List, m_cpuFrustumCullPass.IsInsideList, 0, false);
            }

            m_visibleInstances.Clear();
            foreach (var cullEntity in m_cpuFrustumCullPass.List)
            {
                MyInstanceComponent instance = cullEntity.Owner;
                if (instance.IsVisible(m_cpuFrustumCullPass.PassId))
                {
                    m_visibleInstances.Add(cullEntity.Owner);
                }
            }
        }
Exemplo n.º 4
0
        internal static void Update()
        {
            foreach (var light in m_idIndex.Values)
            {
                if (m_pointlights[light.Index].Enabled || m_spotlights[light.Index].Enabled)
                {
                    var gid = light.ParentGID;
                    if (gid != -1 && MyIDTracker <MyActor> .FindByID((uint)gid) != null)
                    {
                        var matrix = MyIDTracker <MyActor> .FindByID((uint)gid).WorldMatrix;

                        Vector3D.Transform(ref m_lights.Data[light.Index].LocalPointPosition, ref matrix, out m_lights.Data[light.Index].PointPosition);

                        if (m_spotlights[light.Index].Enabled)
                        {
                            Vector3D.Transform(ref m_lights.Data[light.Index].LocalSpotPosition, ref matrix, out m_lights.Data[light.Index].SpotPosition);

                            Vector3.TransformNormal(ref m_lights.Data[light.Index].LocalDirection, ref matrix, out m_lights.Data[light.Index].Direction);
                            Vector3.TransformNormal(ref m_lights.Data[light.Index].LocalUp, ref matrix, out m_lights.Data[light.Index].Up);

                            m_spotlights[light.Index].ViewProjectionDirty = true;
                        }

                        CheckDirty(light);

                        if (light.FlareId != FlareId.NULL)
                        {
                            MyFlareRenderer.Update(light.FlareId);
                        }
                    }
                }
            }

            if (m_dirtyPointlights.Count > 0)
            {
                foreach (var id in m_dirtyPointlights)
                {
                    var proxy    = m_pointlights[id.Index].BvhProxyId;
                    var position = m_lights.Data[id.Index].PointPosition;
                    var range    = m_pointlights[id.Index].Light.Range;

                    var aabb = new BoundingBoxD(position - range, position + range);
                    m_pointlights[id.Index].BvhProxyId            = UpdateBvh(PointlightsBvh, id, m_pointlights[id.Index].Enabled, proxy, ref aabb);
                    m_pointlights[id.Index].LastBvhUpdatePosition = position;
                }

                m_dirtyPointlights.Clear();
            }

            if (m_dirtySpotlights.Count > 0)
            {
                foreach (var id in m_dirtySpotlights)
                {
                    var proxy    = m_spotlights[id.Index].BvhProxyId;
                    var position = m_lights.Data[id.Index].SpotPosition;
                    var dir      = m_lights.Data[id.Index].Direction;
                    var up       = m_lights.Data[id.Index].Up;

                    var aabb = MakeAabbFromSpotlightCone(ref m_spotlights[id.Index], position, dir, up);
                    m_spotlights[id.Index].BvhProxyId            = UpdateBvh(SpotlightsBvh, id, m_spotlights[id.Index].Enabled, proxy, ref aabb);
                    m_spotlights[id.Index].LastBvhUpdatePosition = position;
                    m_spotlights[id.Index].LastBvhUpdateDir      = dir;
                    m_spotlights[id.Index].LastBvhUpdateUp       = up;
                }

                m_dirtySpotlights.Clear();
            }

            BoundingFrustumD viewFrustumClippedD = MyRender11.Environment.Matrices.ViewFrustumClippedD;

            if (MyStereoRender.Enable)
            {
                if (MyStereoRender.RenderRegion == MyStereoRegion.LEFT)
                {
                    viewFrustumClippedD = MyStereoRender.EnvMatricesLeftEye.ViewFrustumClippedD;
                }
                else if (MyStereoRender.RenderRegion == MyStereoRegion.RIGHT)
                {
                    viewFrustumClippedD = MyStereoRender.EnvMatricesRightEye.ViewFrustumClippedD;
                }
            }
            PointlightsBvh.OverlapAllFrustum(ref viewFrustumClippedD, MyLightsRendering.VisiblePointlights);
            SpotlightsBvh.OverlapAllFrustum(ref viewFrustumClippedD, MyLightsRendering.VisibleSpotlights);

            MyLightsRendering.VisibleSpotlights.Sort(new MyLightsCameraDistanceComparer());
        }
Exemplo n.º 5
0
 public void GetAllInFrustum(List <T> result, ref BoundingFrustumD frustum, uint flags = 0)
 {
     tree.OverlapAllFrustum(ref frustum, result, flags, false);
 }