public void Subscribe(Vector3Int location, User user, LOD_Mode mode)
{
if (Columns.ContainsKey(location))
{
Columns[location].Subscribe(user, mode);
}
}
public Column CreateColumn(IUser requester, Vector3Int location, LOD_Mode mode)
{
if (ChunkLoaded(location))
{
return(GetColumn(requester, location, mode));
}
if (ChunkExists(location))
{
return(LoadColumn(requester, location, mode));
}
Column column = new Column(this, RegionDirectory, location);
column.Init((float)SmoothVoxelSettings.voxelsPerMeter, SmoothVoxelSettings.MeterSizeX, SmoothVoxelSettings.MeterSizeY, SmoothVoxelSettings.MeterSizeZ);
column.BuildChunk(mode);
column.Serialize();
Columns[location] = column;
//Logger.Log("Column Size: " + column.GeneratedBlocks);
//Logger.Log("Optimized Size: " + column.surfaceBlocksCount);
return(column);
}
public LOD_Mode Deserialize(LOD_Mode load_mode)
{
if (!File.Exists(ColumnFile))
{
return(LOD_Mode.Empty);
}
FileStream stream = new FileStream(ColumnFile, FileMode.Open, FileAccess.Read, FileShare.Read);
BinaryReader reader = new BinaryReader(stream, System.Text.Encoding.Default);
LoadedFromDisk = true;
Max_Mode = (LOD_Mode)reader.ReadInt32();
Current_Mode = (LOD_Mode)Math.Min((int)load_mode, (int)Max_Mode);
Min = reader.ReadInt32();
Max = reader.ReadInt32();
ReduceDepth = reader.ReadBoolean();
Depth = reader.ReadSingle();
// Load heightmap
byte[] buff = new byte[SurfaceData.Length * 4];
reader.Read(buff, 0, buff.Length);
Buffer.BlockCopy(buff, 0, SurfaceData, 0, buff.Length);
Sampler.SetSurfaceData(SurfaceData);
SurfaceGenerated = true;
if (Max_Mode <= LOD_Mode.Heightmap || Current_Mode <= LOD_Mode.Heightmap)
{
reader.Close();
return(LOD_Mode.Heightmap);
}
col_data.Allocate(ChunkSizeX, ChunkSizeY, ChunkSizeZ);
// Load surface blocks
surfaceBlocksCount = reader.ReadInt32();
buff = new byte[surfaceBlocksCount * 4];
reader.Read(buff, 0, buff.Length);
Buffer.BlockCopy(buff, 0, surfaceBlocks, 0, buff.Length);
Logger.Log("Deserializing from {0} to {1}.", Min, Max);
int start = Get_Flat_Index(0, Math.Max(Min - 1, 0), 0);
int length = ((Max + 1) - (Min - 1)) * ChunkSizeX * ChunkSizeZ;
// Load all block types
reader.Read(blocks_type, start, length);
// Load all block ISO
buff = new byte[length * 4];
reader.Read(buff, 0, buff.Length);
Buffer.BlockCopy(buff, 0, blocks_iso, start, buff.Length);
reader.Close();
FullyLoaded = true;
return((LOD_Mode)Math.Min((int)Current_Mode, (int)Max_Mode));
}
public void Subscribe(User user, LOD_Mode new_mode)
{
lock (_padLock)
{
Mode = (LOD_Mode)Math.Max((int)Mode, (int)new_mode);
if (!Subscribers.Contains(user))
{
Subscribers.Enqueue(user);
}
}
}
public QueueEntry(Vector3Int location, Region region, LOD_Mode mode, User requester, Action <QueueEntry, Column> callback, object meta)
{
Column = location;
Region = region;
Mode = mode;
Requester = requester;
Callback = callback;
Meta = meta;
Subscribers = new ConcurrentQueue <User>();
Subscribers.Enqueue(requester);
}
public Column GetColumn(IUser requester, Vector3Int location, LOD_Mode mode)
{
if (ChunkLoaded(location))
{
Column col = Columns[location];
if (col.Max_Mode < mode)
{
col = LoadColumn(requester, location, mode);
}
return(col);
}
return(LoadColumn(requester, location, mode));
}
public void QueueGeneration(Vector3Int location, Region region, LOD_Mode mode, User requester, Action <QueueEntry, Column> callback, object Meta)
{
if (Columns.ContainsKey(location))
{
Subscribe(location, requester, mode);
return;
}
QueueEntry ent = new QueueEntry(location, region, mode, requester, callback, Meta);
Columns[location] = ent;
genQueue.Enqueue(location);
}
private void ReceiveChunk_cmd(Data data)
{
DebugTimer.Stop();
SafeDebug.Log(string.Format("Received chunk: {0}, Time: {1}.", data.Buffer.Length, DebugTimer.Elapsed()));
BinaryReader reader = GetReaderStream(data.Buffer);
int locX = reader.ReadInt32();
int locY = reader.ReadInt32();
int locZ = reader.ReadInt32();
LOD_Mode mode = (LOD_Mode)reader.ReadByte();
//ColumnPacket packet = new ColumnPacket();
}
public Column LoadColumn(IUser requester, Vector3Int location, LOD_Mode mode)
{
if (!ChunkExists(location))
{
throw new Exception("Column must be created with Region.CreateColumn() before attempting to load chunk.");
}
Column column = new Column(this, RegionDirectory, location);
column.Init((float)SmoothVoxelSettings.voxelsPerMeter, SmoothVoxelSettings.MeterSizeX, SmoothVoxelSettings.MeterSizeY, SmoothVoxelSettings.MeterSizeZ);
LOD_Mode loaded_mode = column.Deserialize(mode);
Columns[location] = column;
return(column);
}
public void RequestColumn(Vector2Int col, LOD_Mode mode, bool has_heightmap)
{
DebugTimer.Start();
BinaryWriter wrt = GetWriterStream(20);
wrt.Write(col.x);
wrt.Write(0);
wrt.Write(col.y);
wrt.Write((int)mode);
wrt.Write(has_heightmap);
client.Send((byte)ServerCodes.RequestChunk, GetBytes(wrt.BaseStream));
wrt.Close();
}
public Column RegenerateColumn(IUser requester, Vector3Int location, LOD_Mode mode)
{
if (!ChunkExists(location))
{
throw new Exception("Chunk must exist in order to be regenerated.");
}
Column column = null;
if (ChunkLoaded(location))
{
column = Columns[location];
}
else
{
column = LoadColumn(requester, location, mode);
}
column.BuildChunk(mode);
column.Serialize();
return(column);
}
public void BuildChunk(LOD_Mode mode = LOD_Mode.Full)
{
Logger.Log("BuildChunk - mode: {0}, Current_Mode: {1}, Max_Mode:{2}", mode, Current_Mode, Max_Mode);
if (mode <= Current_Mode)
{
return;
}
if (mode > Current_Mode && mode <= Max_Mode)
{
Deserialize(mode);
return;
}
// mode must be greater than max
if (Current_Mode == LOD_Mode.Empty)
{
switch (mode)
{
case LOD_Mode.Heightmap:
updateMode = UpdateMode.EmptyToHeightmap;
break;
case LOD_Mode.ReducedDepth:
updateMode = UpdateMode.EmptyToReduced;
break;
case LOD_Mode.Full:
updateMode = UpdateMode.HeightmapToFull;
break;
}
}
else if (Current_Mode == LOD_Mode.Heightmap)
{
switch (mode)
{
case LOD_Mode.ReducedDepth:
updateMode = UpdateMode.HeightmapToReduced;
break;
case LOD_Mode.Full:
updateMode = UpdateMode.HeightmapToFull;
break;
}
}
else if (Current_Mode == LOD_Mode.ReducedDepth)
{
updateMode = UpdateMode.ReducedToFull;
}
else
{
return;
}
Max_Mode = mode;
Current_Mode = mode;
GenerateHeightMap();
if (Max_Mode == LOD_Mode.Heightmap)
{
return;
}
if (Max_Mode == LOD_Mode.ReducedDepth)
{
ReduceDepth = true;
}
Generate();
if (Max_Mode == LOD_Mode.Full)
{
FullyLoaded = true;
}
}
public void RequestChunkGen(Vector3Int chunkCord, Region region, LOD_Mode lod_Version, User requester, bool has_heightmap)
{
GenerationQueue.QueueGeneration(chunkCord, region, (LOD_Mode)lod_Version, requester, (queueEntry, column) => {
Logger.Log("{0} Adding chunk to queue for (Re)generation. LOD Level: {1}.", requester.Name, ((LOD_Mode)lod_Version).ToString());
}, has_heightmap);
}
