public bool Tick() { if ((flags & ChunkFlags.Awake) == 0x00) { return(false); } if ((flags & ChunkFlags.StartedBlocks) == 0x00) { ThreadManager.CreateBlockBuilderThread(this); flags |= ChunkFlags.StartedBlocks; } if ((flags & ChunkFlags.HasBlocks) != 0x00 && (flags & ChunkFlags.StartedMesh) == 0x00) { ThreadManager.CreateMeshBuilderThread(this); flags |= ChunkFlags.StartedMesh; } if ((flags & ChunkFlags.chunkLoaded) != 0x00) { //Debug.Log("loaded" + position.ToString()); } return(true); }
public Chunk(int x, int y, int z) { position.x = x; position.y = y; position.z = z; flags |= ChunkFlags.Awake; }
public override bool QueueChunk(ChunkFlags flags, byte[] data, int dataSize) { if (flags.HasFlag(ChunkFlags.Vital)) { Sequence = (Sequence + 1) % NetworkHelper.MaxSequence; } return(QueueChunkEx(flags, data, dataSize, Sequence)); }
public override bool QueueChunk(ChunkFlags flags, byte[] data, int dataSize) { if (flags.HasFlag(ChunkFlags.VITAL)) { Sequence = (Sequence + 1) % NetworkCore.MAX_SEQUENCE; } return(QueueChunkEx(flags, dataSize, data, Sequence)); }
/// <summary> /// Causes the chunk to detect access paths. /// </summary> public void ChunkDetect() { if (!Flags.HasFlag(ChunkFlags.NEEDS_DETECT)) { DetectChunkAccess(); Flags &= ~ChunkFlags.NEEDS_DETECT; } }
internal ChunkHeader(string chunkName, int chunkType, ChunkFlags chunkFlag, string mimeType, short version, long chunkSize) { m_chunkName = chunkName; m_chunkType = chunkType; m_chunkFlags = chunkFlag; m_mimeType = mimeType; m_version = version; m_chunkSize = chunkSize; }
public ChunkHeader(string chunkName, int chunkType, ChunkFlags chunkFlag, string mimeType, short version, long chunkSize) { this.m_chunkName = chunkName; this.m_chunkType = chunkType; this.m_chunkFlags = chunkFlag; this.m_mimeType = mimeType; this.m_version = version; this.m_chunkSize = chunkSize; }
public void OnBlockDataFinished(Block[,,] blocks, bool isAir = false) //public void OnBlockDataFinished (ChunkData blocks, List<int> lightSourceIndices, bool isAir = false) { { this.blockData = blocks; if (isAir == true) { flags &= ~ChunkFlags.Awake; } flags |= ChunkFlags.HasBlocks; }
public void ChunkDetect() { if (!Flags.HasFlag(ChunkFlags.NEEDS_DETECT)) { DetectChunkAccess(); //chunkAccessDetection = chunkAccessDetection == null ? OwningRegion.TheWorld.Schedule.StartASyncTask(DetectChunkAccess) // : chunkAccessDetection.ReplaceOrFollowWith(OwningRegion.TheWorld.Schedule.AddASyncTask(DetectChunkAccess)); Flags &= ~ChunkFlags.NEEDS_DETECT; } }
public Chunk(string signature, short version, ChunkFlags flags, ISerializable <BinaryStream> payload) { Contract.Requires <ArgumentNullException>(signature != null && payload != null); Contract.Requires(Encoding.UTF8.GetByteCount(signature) == 4); _signature = signature; _version = version; _flags = (short)flags; _payload = payload; }
protected override bool QueueChunkEx(ChunkFlags flags, byte[] data, int dataSize, int sequence) { if (ResendChunkConstruct.DataSize + dataSize + NetworkHelper.MaxChunkHeaderSize > ResendChunkConstruct.Data.Length || ResendChunkConstruct.NumChunks >= NetworkHelper.MaxPacketChunks) { Flush(); } var header = new ChunkHeader { Flags = flags, Size = dataSize, Sequence = sequence }; var dataOffset = ResendChunkConstruct.DataSize; dataOffset = header.Pack(ResendChunkConstruct.Data, dataOffset); Buffer.BlockCopy(data, 0, ResendChunkConstruct.Data, dataOffset, dataSize); ResendChunkConstruct.NumChunks++; ResendChunkConstruct.DataSize = dataOffset + dataSize; if (flags.HasFlag(ChunkFlags.Vital) && !flags.HasFlag(ChunkFlags.Resend)) { SizeOfChunksForResends += 32 + dataSize; if (SizeOfChunksForResends >= NetworkHelper.ConnectionBufferSize) { Disconnect("too weak connection (out of buffer)"); return(false); } var resend = new ChunkResend { Sequence = sequence, Flags = flags, DataSize = dataSize, Data = new byte[dataSize], FirstSendTime = Time.Get(), LastSendTime = Time.Get() }; Buffer.BlockCopy(data, 0, resend.Data, 0, dataSize); ChunksForResends.Add(resend); } return(true); }
public override bool QueueChunkEx(ChunkFlags flags, int dataSize, byte[] data, int sequence) { if (ResendQueueConstruct.DataSize + dataSize + NetworkCore.PACKET_HEADER_SIZE > NetworkCore.MAX_PAYLOAD) { Flush(); } var header = new NetworkChunkHeader { Flags = flags, Size = dataSize, Sequence = sequence }; var chunkDataOffset = ResendQueueConstruct.DataSize; chunkDataOffset = header.Pack(ResendQueueConstruct.Data, chunkDataOffset); Buffer.BlockCopy(data, 0, ResendQueueConstruct.Data, chunkDataOffset, dataSize); chunkDataOffset += dataSize; ResendQueueConstruct.NumChunks++; ResendQueueConstruct.DataSize = chunkDataOffset; if (flags.HasFlag(ChunkFlags.VITAL) && !flags.HasFlag(ChunkFlags.RESEND)) { BufferSize += SIZEOF_NETWORK_CHUNK_RESEND + dataSize; if (BufferSize >= BUFFERSIZE) { Disconnect("too weak connection (out of buffer)"); return(false); } var resend = new NetworkChunkResend { Sequence = sequence, Flags = flags, DataSize = dataSize, Data = new byte[dataSize], FirstSendTime = Time.Get(), LastSendTime = Time.Get() }; Buffer.BlockCopy(data, 0, resend.Data, 0, dataSize); ResendQueue.Enqueue(resend); } return(true); }
/// <summary> /// Loads the chunk from save data. /// </summary> /// <param name="det">The block data.</param> /// <param name="ents">The entity data.</param> public void LoadFromSaveData(ChunkDetails det, ChunkDetails ents) { if (det.Version != 2 || ents.Version != 2) { throw new Exception("invalid save data VERSION: " + det.Version + " and " + ents.Version + "!"); } Flags = det.Flags & ~(ChunkFlags.POPULATING); SetBlockAt(0, 0, 0, BlockInternal.AIR); // Ensure generated if (det.Blocks.Length > 0) { for (int i = 0; i < BlocksInternal.Length; i++) { BlocksInternal[i]._BlockMaterialInternal = Utilities.BytesToUShort(Utilities.BytesPartial(det.Blocks, i * 2, 2)); BlocksInternal[i].BlockData = det.Blocks[BlocksInternal.Length * 2 + i]; BlocksInternal[i].BlockLocalData = det.Blocks[BlocksInternal.Length * 3 + i]; BlocksInternal[i]._BlockPaintInternal = det.Blocks[BlocksInternal.Length * 4 + i]; } FromFile = true; } for (int i = 0; i < Reachability.Length; i++) { Reachability[i] = det.Reachables[i] == 1; } if (ents.Blocks != null && ents.Blocks.Length > 0 && entsToSpawn.Count == 0) { BsonDocument bsd = BsonSerializer.Deserialize(ents.Blocks); if (bsd.ContainsKey("list")) { List <BsonValue> docs = bsd["list"]; for (int i = 0; i < docs.Count; i++) { BsonDocument ent = (BsonDocument)docs[i]; EntityType etype = (EntityType)Enum.Parse(typeof(EntityType), ent["ENTITY_TYPE"].AsString); try { Entity e = OwningRegion.ConstructorFor(etype).Create(OwningRegion, ent); e.EID = ent["ENTITY_ID"].AsInt64; entsToSpawn.Add(e); } catch (Exception ex) { Utilities.CheckException(ex); SysConsole.Output("Spawning an entity of type " + etype, ex); } } } } }
public int Unpack(byte[] inputData, int inputOffset) { Flags = (ChunkFlags)((inputData[inputOffset + 0] >> 6) & 0b11); Size = ((inputData[inputOffset + 0] & 0b111111) << 4) | ((inputData[inputOffset + 1] & 0b1111)); Sequence = -1; if (Flags.HasFlag(ChunkFlags.VITAL)) { Sequence = ((inputData[inputOffset + 1] & 0b1111_0000) << 2) | ((inputData[inputOffset + 2])); return(inputOffset + 3); } return(inputOffset + 2); }
public void OnMeshDataFinished(Mesh graphics, Mesh physics) { if (graphics.vertexCount == 0) { flags &= ~ChunkFlags.Awake; } mesh = graphics; flags |= ChunkFlags.HasMesh; if (physics == null) { return; } world.CreateChunkGameObject(this, graphics, physics); //Debug.Log( Vector3Int.DecimalToBinary(((int) flags).ToString())); }
public void SetBlockAt(int x, int y, int z, Block block) { if ((flags & ChunkFlags.HasBlocks) == 0) { return; } x = negToPos((Mathf.FloorToInt(x)) - (position.x * ChuchMaxWidth)); y = negToPos((Mathf.FloorToInt(y)) - (position.y * ChuchMaxHight)); z = negToPos((Mathf.FloorToInt(z)) - (position.z * ChuchMaxWidth)); // //if is out of Bounds look for other chunk to brake it in.................9 // if (IsWithInBounds(x, y, z)) { blockData[x, y, z] = block; flags &= ~ChunkFlags.StartedMesh; } }
public ChunkAttributes(ICollection <uint> chunkTypes, ChunkFlags chunkFlags, ICollection <AviChunkName> suitableParents) { ChunkTypes = chunkTypes; SuitableParents = suitableParents; ChunkFlags = chunkFlags; }
/// <summary> /// Returns whether the given <paramref name="chunkFlag"/> is set for /// the given <paramref name="chunkName"/>. /// </summary> /// <param name="chunkName">the chunk name</param> /// <param name="chunkFlag">the flag to test</param> /// <returns>true if the flag is set, false otherwise</returns> public static bool IsFlagSet(this AviChunkName chunkName, ChunkFlags chunkFlag) { return((chunkName.GetChunkFlags() & chunkFlag) == chunkFlag); }
public virtual void RemoveFlag(ChunkFlags flag) { this.flags &= ~flag; }
public virtual void AddFlag(ChunkFlags flag) { this.flags |= flag; }
public virtual bool HasFlag(ChunkFlags flag) { return((this.flags & flag) == flag); }
protected abstract bool QueueChunkEx(ChunkFlags flags, byte[] data, int dataSize, int sequence);
public abstract bool QueueChunk(ChunkFlags flags, byte[] data, int dataSize);
/// <summary> /// Creates a new chunk attribute. /// </summary> /// <remarks> /// Use an empty list for <param name="suitableParents"/> to specify /// all container chunks. /// </remarks> /// <param name="chunkType">the chunk type field 4CC as string</param> /// <param name="suitableParents">the suitable parent for the chunk</param> /// <param name="flags">the chunk type flags</param> public AviAttribute(string chunkType, AviChunkName[] suitableParents, ChunkFlags flags) { ChunkType = chunkType; SuitableParents = suitableParents; ChunkFlags = flags; }
protected void BeginChunk(BinaryReader br) { flags = (ChunkFlags)br.ReadUInt32(); Debug.Assert(flags != 0); chunkID = (uint)(flags & ChunkFlags.ChunkIndexMask); chunkType = (D3D11Chunk)chunkID; chunkFlags = SDChunkFlags.NoFlags; if ((flags & ChunkFlags.ChunkCallstack) != 0) { uint numFrames = br.ReadUInt32(); if (numFrames < 4096) { chunkFlags |= SDChunkFlags.HasCallstack; callstack = new ulong[numFrames]; br.Read(callstack, 0, callstack.Length); } else { Console.WriteLine($"Read invalid number of callstack frames:{numFrames}"); br.BaseStream.Position += numFrames * sizeof(ulong); } } if ((flags & ChunkFlags.ChunkThreadID) != 0) { threadID = br.ReadUInt64(); } else { threadID = 0; } if ((flags & ChunkFlags.ChunkDuration) != 0) { durationMicro = br.ReadInt64(); } else { durationMicro = -1; } if ((flags & ChunkFlags.ChunkTimestamp) != 0) { timestampMicro = br.ReadUInt64(); } else { timestampMicro = 0; } if ((flags & ChunkFlags.Chunk64BitSize) != 0) { length = br.ReadUInt64(); } else { length = br.ReadUInt32(); } headerLength = br.BaseStream.Position - offset; }
public void LoadFromSaveData(ChunkDetails det, ChunkDetails ents) { if (det.Version != 2 || ents.Version != 2) { throw new Exception("invalid save data VERSION: " + det.Version + " and " + ents.Version + "!"); } Flags = det.Flags & ~(ChunkFlags.POPULATING); for (int i = 0; i < BlocksInternal.Length; i++) { BlocksInternal[i]._BlockMaterialInternal = Utilities.BytesToUshort(Utilities.BytesPartial(det.Blocks, i * 2, 2)); BlocksInternal[i].BlockData = det.Blocks[BlocksInternal.Length * 2 + i]; BlocksInternal[i].BlockLocalData = det.Blocks[BlocksInternal.Length * 3 + i]; BlocksInternal[i]._BlockPaintInternal = det.Blocks[BlocksInternal.Length * 4 + i]; } for (int i = 0; i < Reachability.Length; i++) { Reachability[i] = det.Reachables[i] == 1; } if (ents.Blocks != null && ents.Blocks.Length > 0 && entsToSpawn.Count == 0) { BsonDocument bsd = BsonSerializer.Deserialize(ents.Blocks); if (bsd.ContainsKey("list")) { List<BsonValue> docs = bsd["list"]; for (int i = 0; i < docs.Count; i++) { BsonDocument ent = (BsonDocument)docs[i]; EntityType etype = (EntityType)Enum.Parse(typeof(EntityType), ent["ENTITY_TYPE"].AsString); try { Entity e = OwningRegion.ConstructorFor(etype).Create(OwningRegion, ent); e.EID = ent["ENTITY_ID"].AsInt64; entsToSpawn.Add(e); } catch (Exception ex) { Utilities.CheckException(ex); SysConsole.Output("Spawning an entity of type " + etype, ex); } } } } }
public abstract bool QueueChunkEx(ChunkFlags flags, int dataSize, byte[] data, int sequence);