Esempio n. 1
0
    public void WriteChunkToFile(Streaming.IChunkIO chunk)
    {
        if (_chunkWrite != null)
        {
            ++_modifyCount;

            long ofs  = 0;
            long size = 0;

            if ((chunk.flags & EChunkFlags.SOLID) != 0)
            {
                ofs = _chunkWrite.BaseStream.Position;
                WriteChunkDataToFile(_chunkWrite, chunk);
                size = _chunkWrite.BaseStream.Position - ofs;
            }

            var chunkFile = new ChunkFile_t()
            {
                pos         = chunk.chunkPos,
                ofs         = (uint)ofs,
                size        = (uint)size,
                flags       = (uint)chunk.flags,
                modifyCount = _modifyCount
            };
            _chunkFiles[chunkFile.pos] = chunkFile;
        }
    }
 protected override void WriteChunkData(Streaming.IChunkIO chunk)
 {
     _gameMode.worldStreaming.WriteChunkData(chunk);
 }
Esempio n. 3
0
    static void WriteChunkDataToFile(BinaryWriter file, Streaming.IChunkIO chunk)
    {
        {
            var decorationCount = chunk.decorationCount;
            file.Write(decorationCount);
            for (int i = 0; i < decorationCount; ++i)
            {
                var d = chunk.decorations[i];
                file.Write(d.pos.x);
                file.Write(d.pos.y);
                file.Write(d.pos.z);
                file.Write((int)d.type);
            }
        }

        var numVoxels = chunk.voxeldata.Length;

        for (int i = 0; i < numVoxels; ++i)
        {
            file.Write(chunk.voxeldata[i].raw);
        }

        var verts = chunk.verts;
        var flags = chunk.flags;

        for (int i = 0; i < verts.counts.Length; ++i)
        {
            file.Write(verts.counts[i]);
        }

        for (int i = 0; i < verts.submeshes.Length; ++i)
        {
            file.Write(verts.submeshes[i]);
        }

        var totalVerts   = 0;
        var totalIndices = 0;

        for (int layer = 0; layer < ChunkLayers.Length; ++layer)
        {
            if ((flags & ((EChunkFlags)((int)EChunkFlags.LAYER_DEFAULT << layer))) != 0)
            {
                var numLayerVerts = verts.counts[layer * 3 + 0];
                if (numLayerVerts > 0)
                {
                    totalVerts += numLayerVerts;

                    var maxSubmesh = verts.counts[layer * 3 + 2];
                    for (int submesh = 0; submesh <= maxSubmesh; ++submesh)
                    {
                        var numSubmeshVerts = verts.submeshes[(layer * MAX_CHUNK_LAYERS) + submesh];
                        totalIndices += numSubmeshVerts;
                    }
                }
            }
        }

        file.Write(totalVerts);
        file.Write(totalIndices);

        if (totalVerts > 0)
        {
            for (int i = 0; i < totalVerts; ++i)
            {
                var v3 = verts.positions[i];
                file.Write(v3.x);
                file.Write(v3.y);
                file.Write(v3.z);
            }
            for (int i = 0; i < totalVerts; ++i)
            {
                var v3 = verts.normals[i];
                file.Write(v3.x);
                file.Write(v3.y);
                file.Write(v3.z);
            }
            for (int i = 0; i < totalVerts; ++i)
            {
                var c = verts.colors[i];
                file.Write(c.ToUIntRGBA());
            }
            for (int i = 0; i < totalIndices; ++i)
            {
                file.Write(verts.indices[i]);
            }
        }
    }
Esempio n. 4
0
 protected abstract void WriteChunkData(Streaming.IChunkIO chunk);