예제 #1
0
        public void DebugDraw()
        {
            return;

            MyStateObjects.WireframeRasterizerState.Apply();
            for (int i = 0; i < NumSplits; i++)
            {
                cameraFrustum.Matrix = m_lightCameras[i].CameraSubfrustum;
                cameraFrustum.GetCorners(frustum);

                var tmp = frustum[3];
                frustum[3] = frustum[2];
                frustum[2] = tmp;

                //MyDebugDraw.DrawBoundingFrustum(cameraFrustum, frustumColors[i]);
                MySimpleObjectDraw.OcclusionPlaneDraw(frustum);
                //MyDebugDraw.DrawTriangle(frustum[0], frustum[1], frustum[2], frustumColors[i], frustumColors[i], frustumColors[i]);
                //MyDebugDraw.DrawTriangle(frustum[1], frustum[2], frustum[3], frustumColors[i], frustumColors[i], frustumColors[i]);
            }

            return;

            bool update = false;

            if (MyRender.CurrentRenderSetup.CallerID.Value == MyRenderCallerEnum.Main)
            {
                if (update)
                {
                    mainCamera = MyCamera.GetBoundingFrustum().Matrix;
                }

                for (int i = 0; i < NumSplits; i++)
                {
                    if (update)
                    {
                        Vector4 c = frustumColors[i].ToVector4();

                        //MyDebugDraw.DrawAABBLowRes(ref box, ref c, 1);
                        //BoundingFrustum bf = new BoundingFrustum();

                        //frustumMatrices[i] = m_lightCameras[i].CameraSubfrustum;
                        frustumMatrices[i] = m_lightCameras[i].BoundingFrustum.Matrix;
                    }

                    DebugDrawFrustum(frustumMatrices[i], frustumColors[i]);


                    Vector4 cc = frustumColors[i].ToVector4();

                    BoundingFrustum frma = new BoundingFrustum(frustumMatrices[i]);
                    MyRender.PrepareEntitiesForDraw(ref frma, Vector3.Zero, 0, (MyOcclusionQueryID)(i + 1), m_castingRenderObjects, m_castingCullObjects, m_occlusionQueriesLists[i], ref MyPerformanceCounter.PerCameraDraw.ShadowEntitiesOccluded[i]);
                    BoundingBox aabbFr = new BoundingBox();
                    aabbFr = aabbFr.CreateInvalid();
                    foreach (MyRenderObject ro in m_castingRenderObjects)
                    {
                        BoundingBox vv = ro.GetWorldSpaceAABB();
                        //MyDebugDraw.DrawAABBLowRes(ref vv, ref cc, 1);
                        aabbFr = aabbFr.Include(ref vv);
                    }


                    //MyDebugDraw.DrawAABBLowRes(ref aabbFr, ref cc, 1);
                }

                // DebugDrawFrustum(mainCamera, new Color(1.0f, 1.0f, 1.0f));
            }
        }
예제 #2
0
        void PrepareCascadesForDraw()
        {
            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("UpdateFrustums");

            SunLightDirection = -MyGuiScreenGamePlay.Static.GetDirectionToSunNormalized();
            SunPosition       = 100000 * -SunLightDirection;
            UpdateFrustums();

            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();

            // Set casting shadows geometry

            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("update entities");

            int frustumIndex = 0;

            foreach (MyOrthographicCamera lightCamera in m_lightCameras)
            {
                if (m_skip[frustumIndex])
                {
                    frustumIndex++;
                    continue;
                }

                m_renderElementsForShadows.Clear();
                m_transparentRenderElementsForShadows.Clear();
                m_castingRenderObjectsUnique.Clear();

                MyRender.GetRenderProfiler().StartProfilingBlock("OverlapAllBoundingBox");


                BoundingBox     castersBox     = lightCamera.BoundingBox;     //Cannot use unscaled - incorrect result because of different cascade viewport size
                BoundingFrustum castersFrustum = lightCamera.BoundingFrustum; //Cannot use unscaled - incorrect result because of different cascade viewport size
                //MyRender.PrepareEntitiesForDraw(ref castersBox, (MyOcclusionQueryID)(frustumIndex + 1), m_castingRenderObjects, m_occlusionQueriesLists[frustumIndex], ref MyPerformanceCounter.PerCameraDraw.ShadowEntitiesOccluded[frustumIndex]);
                MyRender.PrepareEntitiesForDraw(ref castersFrustum, lightCamera.Position, 1, (MyOcclusionQueryID)(frustumIndex + 1), m_castingRenderObjects, m_castingCullObjects, null, ref MyPerformanceCounter.PerCameraDraw.ShadowEntitiesOccluded[frustumIndex]);

                MyRender.GetRenderProfiler().EndProfilingBlock();

                MyRender.GetRenderProfiler().StartProfilingBlock("m_castingRenderObjects");

                int c       = 0;
                int skipped = 0;

                while (c < m_castingRenderObjects.Count)
                {
                    MyRenderObject renderObject = (MyRenderObject)m_castingRenderObjects[c];
                    MyEntity       entity       = renderObject.Entity;

                    //TODO: Appears in Chinese Escape when reloaded several times
                    //System.Diagnostics.Debug.Assert(!entity.NearFlag);

                    if (RespectCastShadowsFlags)
                    {
                        System.Diagnostics.Debug.Assert(!(entity is MyDummyPoint) && !(entity is MinerWars.AppCode.Game.Entities.WayPoints.MyWayPoint));

                        if ((renderObject.ShadowCastUpdateInterval > 0) && ((MyRender.RenderCounter % renderObject.ShadowCastUpdateInterval) == 0))
                        {
                            renderObject.NeedsResolveCastShadow = true;
                            //We have to leave last value, because true when not casting shadow make radiation to ship
                            // renderObject.CastShadow = true;
                        }

                        if (renderObject.NeedsResolveCastShadow)
                        { //Resolve raycast to sun
                            if (renderObject.CastShadowJob == null)
                            {
                                renderObject.CastShadowJob  = new MyCastShadowJob(entity);
                                renderObject.CastShadowTask = ParallelTasks.Parallel.Start(renderObject.CastShadowJob);
                            }
                            else
                            if (renderObject.CastShadowTask.IsComplete)
                            {
                                renderObject.CastShadow             = renderObject.CastShadowJob.VisibleFromSun;
                                renderObject.CastShadowTask         = new ParallelTasks.Task();
                                renderObject.CastShadowJob          = null;
                                renderObject.NeedsResolveCastShadow = false;
                            }
                        }

                        if (!renderObject.NeedsResolveCastShadow && !renderObject.CastShadow)
                        {
                            m_castingRenderObjects.RemoveAtFast(c);
                            skipped++;
                            continue;
                        }
                    }
                    else
                    {
                        renderObject.NeedsResolveCastShadow = true;
                    }

                    /*
                     * //Skip object depending on their size and cascade
                     * if (entity.WorldVolume.Radius < (frustumIndex + 1) * 5)
                     * {
                     *  m_castingRenderObjects.RemoveAtFast(c);
                     *  continue;
                     * }
                     */

                    if (entity != null)
                    {
                        if (!m_castingRenderObjectsUnique.Contains(renderObject))
                        {
                            m_castingRenderObjectsUnique.Add(renderObject);

                            if (frustumIndex < MyRenderConstants.RenderQualityProfile.ShadowCascadeLODTreshold)
                            {
                                if (entity is MyVoxelMap)
                                {
                                    //(entity as MyVoxelMap).GetRenderElementsForShadowmap(m_renderElementsForShadows, ref castersBox, castersFrustum, MyLodTypeEnum.LOD0, true);
                                    (entity as MyVoxelMap).GetRenderElementsForShadowmap(m_renderElementsForShadows, renderObject.RenderCellCoord.Value, MyLodTypeEnum.LOD0, true);
                                }

                                else
                                if (entity.ModelLod0 != null)
                                {
                                    MyRender.CollectRenderElementsForShadowmap(m_renderElementsForShadows, m_transparentRenderElementsForShadows,
                                                                               entity, entity.ModelLod0);
                                }
                            }
                            else
                            {
                                if (entity is MyVoxelMap)
                                {
                                    (entity as MyVoxelMap).GetRenderElementsForShadowmap(m_renderElementsForShadows, renderObject.RenderCellCoord.Value, MyLodTypeEnum.LOD1, true);
                                }
                                else
                                if (entity.ModelLod1 != null)
                                {
                                    MyRender.CollectRenderElementsForShadowmap(m_renderElementsForShadows, m_transparentRenderElementsForShadows,
                                                                               entity, entity.ModelLod1);
                                }
                            }
                        }
                    }

                    c++;
                }

                MyRender.GetRenderProfiler().EndProfilingBlock();

                //Sorting VBs to minimize VB switches
                m_renderElementsForShadows.Sort(m_shadowElementsComparer);

                lightCamera.CastingRenderElements = m_renderElementsForShadows;

                MyPerformanceCounter.PerCameraDraw.RenderElementsInShadows += m_renderElementsForShadows.Count;

                frustumIndex++;
            }

            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();
        }