/// <summary> /// Resets stream for reading. /// </summary> public void ResetRead(IntPtr buffer, int bitLength, bool copy) { if (copy) { int byteLen = MyLibraryUtils.GetDivisionCeil(bitLength, 8); int allocByteSize = Math.Max(byteLen, m_defaultByteSize); if (m_ownedBuffer == null) { m_ownedBuffer = (ulong *)(void *)SharpDX.Utilities.AllocateClearedMemory(allocByteSize); m_ownedBufferBitLength = allocByteSize * 8; } else if (m_ownedBufferBitLength < bitLength) { SharpDX.Utilities.FreeMemory((IntPtr)(void *)m_ownedBuffer); m_ownedBuffer = (ulong *)(void *)SharpDX.Utilities.AllocateClearedMemory(allocByteSize); m_ownedBufferBitLength = allocByteSize * 8; } SharpDX.Utilities.CopyMemory((IntPtr)(void *)m_ownedBuffer, buffer, byteLen); m_buffer = m_ownedBuffer; m_bitLength = bitLength; m_bitPosition = 0; m_writing = false; } else { m_buffer = (ulong *)(void *)buffer; m_bitLength = bitLength; m_bitPosition = 0; m_writing = false; } }
private void WritePart(ref int bitsToSend, StreamClientData clientData, byte packetId, ref VRage.Library.Collections.BitStream stream) { bitsToSend = Math.Min(m_streamSize, clientData.RemainingBits); StreamPartInfo info = new StreamPartInfo(); info.StartIndex = clientData.LastPosition; info.NumBits = bitsToSend; clientData.LastPosition = info.StartIndex + MyLibraryUtils.GetDivisionCeil(m_streamSize, 8); clientData.SendPackets[packetId] = info; clientData.RemainingBits = Math.Max(0, clientData.RemainingBits - m_streamSize); stream.WriteInt16(clientData.NumParts); stream.WriteInt16(clientData.CurrentPart); info.Position = clientData.CurrentPart; clientData.CurrentPart++; stream.WriteInt32(bitsToSend); unsafe { fixed(byte *dataPtr = &clientData.ObjectData[info.StartIndex]) { stream.WriteMemory(dataPtr, bitsToSend); } } }
private void ProcessWrite(int maxBitPosition, ref VRage.Library.Collections.BitStream stream, EndpointId forClient, byte packetId) { m_streamSize = MyLibraryUtils.GetDivisionCeil(maxBitPosition - stream.BitPosition - HEADER_SIZE - SAFE_VALUE, 8) * 8; StreamClientData clientData = m_clientStreamData[forClient.Value]; if (clientData.FailedIncompletePackets.Count > 0) { stream.WriteBool(true); WriteIncompletePacket(clientData, packetId, ref stream); return; } int bitsToSend = 0; bool incomplete = false; if (clientData.ObjectData == null) { SaveReplicable(clientData); } else { incomplete = true; } clientData.NumParts = (short)MyLibraryUtils.GetDivisionCeil(clientData.ObjectData.Length * 8, m_streamSize); bitsToSend = clientData.RemainingBits; if (bitsToSend == 0) { clientData.ForceSend = false; clientData.Dirty = false; stream.WriteBool(false); return; } stream.WriteBool(true); stream.WriteInt32(clientData.UncompressedSize); if (bitsToSend > m_streamSize || incomplete) { WritePart(ref bitsToSend, clientData, packetId, ref stream); } else { WriteWhole(bitsToSend, clientData, packetId, ref stream); } if (clientData.RemainingBits == 0) { clientData.Dirty = false; clientData.ForceSend = false; } }
void CreateFromString(string s) { if (!Enum.TryParse <T>(s, out EnumType)) { EnumType = (T)Enum.ToObject(typeof(T), MyLibraryUtils.GetHash(s)); } #if SUPPORT_STRING_SAVE EnumString = s; #endif m_enumInt = ((IConvertible)EnumType).ToInt32(System.Globalization.CultureInfo.InvariantCulture); }
/// <summary> /// Resets stream for writing. /// Uses internal buffer for writing, it's available as DataPointer. /// </summary> public void ResetWrite() { if (m_ownedBuffer == null) { m_ownedBuffer = (ulong *)(void *)SharpDX.Utilities.AllocateClearedMemory(m_defaultByteSize); m_ownedBufferBitLength = m_defaultByteSize * 8; } else { SharpDX.Utilities.ClearMemory((IntPtr)(void *)m_ownedBuffer, 0, MyLibraryUtils.GetDivisionCeil(m_ownedBufferBitLength, 8)); } m_buffer = m_ownedBuffer; m_bitLength = m_ownedBufferBitLength; m_bitPosition = 0; m_writing = true; }
private bool ReadPart(ref VRage.Library.Collections.BitStream stream) { m_numPartsToRecive = stream.ReadInt16(); short currentPacket = stream.ReadInt16(); int bitsToRecieve = stream.ReadInt32(); int bytesToRecieve = MyLibraryUtils.GetDivisionCeil(bitsToRecieve, 8); int numBitsInStream = stream.BitLength - stream.BitPosition; if (numBitsInStream < bitsToRecieve) { Debug.Fail("trying to read more than there is in stream. Why ?"); MyLog.Default.WriteLine("trying to read more than there is in stream. Total num parts : " + m_numPartsToRecive.ToString() + " current part : " + currentPacket.ToString() + " bits to read : " + bitsToRecieve.ToString() + " bits in stream : " + numBitsInStream.ToString() + " replicable : " + Instance.ToString()); //what now ? return(false); } if (m_recivedParts == null) { m_recivedParts = new SortedList <StreamPartInfo, byte[]>(); } m_recievedBytes += bytesToRecieve; byte[] partData = new byte[bytesToRecieve]; unsafe { fixed(byte *dataPtr = partData) { stream.ReadMemory(dataPtr, bitsToRecieve); } } StreamPartInfo info = new StreamPartInfo(); info.NumBits = bitsToRecieve; info.StartIndex = currentPacket; m_recivedParts[info] = partData; return(true); }
public void ResetWrite(BitStream stream) { int bitLength = stream.m_writing ? stream.m_bitPosition : stream.BitLength; if (m_ownedBuffer != null && m_ownedBufferBitLength < bitLength) { SharpDX.Utilities.FreeMemory((IntPtr)(void *)m_ownedBuffer); m_ownedBuffer = null; } if (m_ownedBuffer == null) { int byteSize = Math.Max(MyLibraryUtils.GetDivisionCeil(bitLength, 64) * 8, m_defaultByteSize); m_ownedBuffer = (ulong *)(void *)SharpDX.Utilities.AllocateClearedMemory(byteSize); m_ownedBufferBitLength = byteSize * 8; } m_buffer = m_ownedBuffer; m_bitLength = m_ownedBufferBitLength; SharpDX.Utilities.CopyMemory(DataPointer, stream.DataPointer, MyLibraryUtils.GetDivisionCeil(bitLength, 8)); m_bitPosition = bitLength; m_writing = true; }
void Resize(int bitSize) { if (!OwnsBuffer) { throw new BitStreamException("BitStream cannot write more data. Buffer is full and it's not owned by BitStream", new System.IO.EndOfStreamException()); } // Always at least double the size int newBitSize = Math.Max(m_bitLength * 2, bitSize); int newByteLen = MyLibraryUtils.GetDivisionCeil(newBitSize, 64) * 8; var newBuffer = SharpDX.Utilities.AllocateClearedMemory(newByteLen); SharpDX.Utilities.CopyMemory(newBuffer, (IntPtr)(void *)m_buffer, BytePosition); SharpDX.Utilities.FreeMemory((IntPtr)(void *)m_buffer); m_buffer = (ulong *)(void *)newBuffer; m_bitLength = newBitSize; m_ownedBuffer = m_buffer; m_ownedBufferBitLength = m_bitLength; }
public void AddEdgeInfo(ref Vector3 point0, ref Vector3 point1, ref Vector3 normal0, ref Vector3 normal1, Color color, MySlimBlock owner) { var hash = CalculateEdgeHash(point0, point1); var pos = (point0 + point1) * 0.5f; Vector3I direction = Vector3I.Round((point0 - point1) / m_gridRender.GridSize); MyEdgeInfo info = new MyEdgeInfo(ref pos, ref direction, ref normal0, ref normal1, ref color, MyLibraryUtils.GetHash(owner.BlockDefinition.EdgeType)); var cell = GetCell(pos); if (cell.AddEdgeInfo(hash, info, owner)) { m_dirtyCells.Add(cell); } }
/// <summary> /// Writes uniform-spaced float within -1,1 range with specified number of bits. /// </summary> public void WriteNormalizedSignedFloat(float value, int bits) { WriteUInt32(MyLibraryUtils.NormalizeFloatCenter(value, -1, 1, bits), bits); }
/// <summary> /// Reads uniform-spaced float within -1,1 range with specified number of bits. /// </summary> public float ReadNormalizedSignedFloat(int bits) { return(MyLibraryUtils.DenormalizeFloatCenter(ReadUInt32(bits), -1, 1, bits)); }
public BitStream(int defaultByteSize = 1536) { // At least 16 bytes m_defaultByteSize = Math.Max(16, MyLibraryUtils.GetDivisionCeil(defaultByteSize, 8) * 8); }
public BlitSerializer() { MyLibraryUtils.ThrowNonBlittable <T>(); }