Exemple #1
0
        static void SaveVoxel(MyVoxelMap voxelMap)
        {
            Debug.Assert(voxelMap.EntityId != null);

            using (var voxelStream = new FileStream(GetVoxelPath(voxelMap), FileMode.Create))
                using (var voxelWriter = new BinaryWriter(voxelStream))
                {
                    voxelWriter.Write(MyMwcFinalBuildConstants.VOXEL_CACHE_FILE_VERSION);

                    MyMwcVector3Int cellCoord;
                    for (cellCoord.X = 0; cellCoord.X < voxelMap.DataCellsCount.X; cellCoord.X++)
                    {
                        for (cellCoord.Y = 0; cellCoord.Y < voxelMap.DataCellsCount.Y; cellCoord.Y++)
                        {
                            for (cellCoord.Z = 0; cellCoord.Z < voxelMap.DataCellsCount.Z; cellCoord.Z++)
                            {
                                var dataCell = MyVoxelCacheData.GetCell(voxelMap, ref cellCoord, false);
                                if (dataCell != null /* && dataCell.VoxelTrianglesCount > 0*/)
                                {
                                    voxelWriter.Write(cellCoord.X);
                                    voxelWriter.Write(cellCoord.Y);
                                    voxelWriter.Write(cellCoord.Z);

                                    dataCell.Write(voxelWriter);

                                    //Log("update", sectorIdentifier, checkpointName, sector.Version);
                                }
                            }
                        }
                    }
                }
        }
Exemple #2
0
        static bool LoadVoxel(MyVoxelMap voxelMap)
        {
            var voxelFile = GetVoxelPath(voxelMap);

            if (File.Exists(voxelFile))
            {
                using (FileStream voxelStream = new FileStream(voxelFile, FileMode.Open))
                    using (BinaryReader voxelReader = new BinaryReader(voxelStream))
                    {
                        var fileVersion = voxelReader.ReadInt32();

                        if (fileVersion != MyMwcFinalBuildConstants.VOXEL_CACHE_FILE_VERSION)
                        {
                            //Log("outdated file", sector, checkpointName, result.Version);
                            File.Delete(voxelFile);
                            return(false);
                        }

                        while (voxelStream.Length != voxelStream.Position)
                        {
                            MyMwcVector3Int cellCoord;
                            cellCoord.X = voxelReader.ReadInt32();
                            cellCoord.Y = voxelReader.ReadInt32();
                            cellCoord.Z = voxelReader.ReadInt32();

                            var dataCell = MyVoxelCacheData.AddCell(voxelMap.VoxelMapId, ref cellCoord);

                            var fakeEndpoint = new IPEndPoint(0, 0);
                            //MyMwcMessageIn.ReadObjectBuilderTypeEnumEx(voxelReader, fakeEndpoint);
                            var readSuccessfully = dataCell.Read(voxelReader, fakeEndpoint);

                            if (!readSuccessfully)
                            {
                                MyVoxelCacheData.RemoveCell(voxelMap.VoxelMapId, ref cellCoord);
                                File.Delete(voxelFile);
                                //Log("corrupted file", sector, checkpointName, result.Version);
                                return(false);
                            }

                            //= MyMwcObjectBuilder_Base.FromBytes<MyMwcObjectBuilder_VoxelDataCell>(voxelReader.ReadBytes((int)sectorStream.Length));

                            //Log("update", sectorIdentifier, checkpointName, sector.Version);
                        }
                        //result = MyMwcObjectBuilder_Base.FromBytes<MyMwcObjectBuilder_Sector>(sectorReader.ReadBytes((int)sectorStream.Length));
                    }
                //Log("hit", sector, checkpointName, result.Version);
            }
            else
            {
                //Log("miss", sector, checkpointName);
                return(false);
            }

            return(true);
        }
        private static MyVoxelCacheCellRender LoadCell(
            MyVoxelMap voxelMap, ref MyMwcVector3Int renderCellCoord, MyLodTypeEnum cellHashType)
        {
            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("AddCell");

            MyVoxelCacheCellRender ret = AddCell(voxelMap.VoxelMapId, ref renderCellCoord, cellHashType);

            ret.Begin(voxelMap, ref renderCellCoord);
            ret.CellHashType = cellHashType;

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

            if (cellHashType == MyLodTypeEnum.LOD0)
            {
                MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("cellHashType LOD0");
                m_dataCellsQueue.Clear();

                //  Create normal (LOD0) version
                for (int dataX = 0; dataX < MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE; dataX++)
                {
                    for (int dataY = 0; dataY < MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE; dataY++)
                    {
                        for (int dataZ = 0; dataZ < MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE; dataZ++)
                        {
                            //  Don't precalculate this cells now. Store it in queue and calculate all cells at once by MyVoxelPrecalc.PrecalcQueue()
                            MyMwcVector3Int dataCellCoord =
                                new MyMwcVector3Int(
                                    renderCellCoord.X * MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE + dataX,
                                    renderCellCoord.Y * MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE + dataY,
                                    renderCellCoord.Z * MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE + dataZ);
                            MyVoxelCacheCellData cachedDataCell = MyVoxelCacheData.GetCellLater(voxelMap, ref dataCellCoord);
                            if (cachedDataCell != null)
                            {
                                m_dataCellsQueue.Add(cachedDataCell);
                            }
                        }
                    }
                }

                MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("PrecalcQueue LOD0");

                //  Precalculate all queued data cells in parallel threads - using multiple cores if possible.
                MyVoxelPrecalc.PrecalcQueue();

                if (MyFakes.SIMPLIFY_VOXEL_MESH)
                {
                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("Stitch Data Cells LOD0");
                    MyDataCellStitcher.StitchDataCells(m_dataCellsQueue);

                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("Decimate mesh LOD0");
                    MyMeshSimplifier.Instance.SimplifyMesh(MyDataCellStitcher.Vertices, MyDataCellStitcher.Triangles);

                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("AddTriangles LOD0");
                    ret.AddTriangles(MyDataCellStitcher.Vertices, MyDataCellStitcher.Triangles);
                }
                else
                {
                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("AddTriangles LOD0");
                    ret.AddTriangles(m_dataCellsQueue);
                }

                //  Iterate all data cells and copy their triangles to this render cell
                //for (int i = 0; i < m_dataCellsQueue.Count; i++)
                //{
                //    ret.AddTriangles(m_dataCellsQueue[i]);
                //}
                MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();
            }
            else if (cellHashType == MyLodTypeEnum.LOD1)
            {
                MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("cellHashType LOD1");

                m_helperLodCachedDataCell.Reset();

                //  Create LOD1 render cell
                MyVoxelPrecalc.PrecalcImmediatelly(
                    new MyVoxelPrecalcTaskItem(
                        MyLodTypeEnum.LOD1,
                        voxelMap,
                        m_helperLodCachedDataCell,
                        new MyMwcVector3Int(
                            renderCellCoord.X * MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE,
                            renderCellCoord.Y * MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE,
                            renderCellCoord.Z * MyVoxelConstants.VOXEL_DATA_CELLS_IN_RENDER_CELL_SIZE)));


                MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("m_dataCellsQueue LOD1");
                m_dataCellsQueue.Clear();
                m_dataCellsQueue.Add(m_helperLodCachedDataCell);


                if (MyFakes.SIMPLIFY_VOXEL_MESH)
                {
                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("Stitch data cells LOD1");
                    MyDataCellStitcher.StitchDataCells(m_dataCellsQueue);

                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("Decimate mesh LOD1");
                    MyMeshSimplifier.Instance.SimplifyMesh(MyDataCellStitcher.Vertices, MyDataCellStitcher.Triangles);

                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("AddTriangles LOD1");
                    ret.AddTriangles(MyDataCellStitcher.Vertices, MyDataCellStitcher.Triangles);
                }
                else
                {
                    MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("AddTriangles LOD1");
                    ret.AddTriangles(m_dataCellsQueue);
                }

                MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();
            }
            else
            {
                throw new MyMwcExceptionApplicationShouldNotGetHere();
            }

            ret.End();
            return(ret);
        }