#include <BitStream.h>
Public Member Functions | |
| BitStream () | |
| Default Constructor. | |
| BitStream (const unsigned int initialBytesToAllocate) | |
| Create the bitstream, with some number of bytes to immediately allocate. | |
| BitStream (unsigned char *_data, const unsigned int lengthInBytes, bool _copyData) | |
| Initialize the BitStream, immediately setting the data it contains to a predefined pointer. | |
| ~BitStream () | |
| void | Reset (void) |
| Resets the bitstream for reuse. | |
| template<class templateType > | |
| bool | Serialize (bool writeToBitstream, templateType &inOutTemplateVar) |
| Bidirectional serialize/deserialize any integral type to/from a bitstream. | |
| template<class templateType > | |
| bool | SerializeDelta (bool writeToBitstream, templateType &inOutCurrentValue, templateType lastValue) |
| Bidirectional serialize/deserialize any integral type to/from a bitstream. | |
| template<class templateType > | |
| bool | SerializeDelta (bool writeToBitstream, templateType &inOutCurrentValue) |
| Bidirectional version of SerializeDelta when you don't know what the last value is, or there is no last value. | |
| template<class templateType > | |
| bool | SerializeCompressed (bool writeToBitstream, templateType &inOutTemplateVar) |
| Bidirectional serialize/deserialize any integral type to/from a bitstream. | |
| template<class templateType > | |
| bool | SerializeCompressedDelta (bool writeToBitstream, templateType &inOutCurrentValue, templateType lastValue) |
| Bidirectional serialize/deserialize any integral type to/from a bitstream. | |
| template<class templateType > | |
| bool | SerializeCompressedDelta (bool writeToBitstream, templateType &inOutTemplateVar) |
| Save as SerializeCompressedDelta(templateType ¤tValue, templateType lastValue) when we have an unknown second parameter. | |
| bool | Serialize (bool writeToBitstream, char *inOutByteArray, const unsigned int numberOfBytes) |
| Bidirectional serialize/deserialize an array or casted stream or raw data. This does NOT do endian swapping. | |
| bool | SerializeFloat16 (bool writeToBitstream, float &inOutFloat, float floatMin, float floatMax) |
| Serialize a float into 2 bytes, spanning the range between floatMin and floatMax. | |
| template<class serializationType , class sourceType > | |
| bool | SerializeCasted (bool writeToBitstream, sourceType &value) |
| template<class templateType , class rangeType > | |
| bool | SerializeBitsFromIntegerRange (bool writeToBitstream, templateType &value, const rangeType minimum, const rangeType maximum, bool allowOutsideRange=false) |
| template<class templateType , class rangeType > | |
| bool | SerializeBitsFromIntegerRange (bool writeToBitstream, templateType &value, const rangeType minimum, const rangeType maximum, const int requiredBits, bool allowOutsideRange=false) |
| template<class templateType > | |
| bool | SerializeNormVector (bool writeToBitstream, templateType &x, templateType &y, templateType &z) |
| Bidirectional serialize/deserialize a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes. | |
| template<class templateType > | |
| bool | SerializeVector (bool writeToBitstream, templateType &x, templateType &y, templateType &z) |
| Bidirectional serialize/deserialize a vector, using 10 bytes instead of 12. | |
| template<class templateType > | |
| bool | SerializeNormQuat (bool writeToBitstream, templateType &w, templateType &x, templateType &y, templateType &z) |
| Bidirectional serialize/deserialize a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy. | |
| template<class templateType > | |
| bool | SerializeOrthMatrix (bool writeToBitstream, templateType &m00, templateType &m01, templateType &m02, templateType &m10, templateType &m11, templateType &m12, templateType &m20, templateType &m21, templateType &m22) |
| Bidirectional serialize/deserialize an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each. | |
| bool | SerializeBits (bool writeToBitstream, unsigned char *inOutByteArray, const BitSize_t numberOfBitsToSerialize, const bool rightAlignedBits=true) |
| Bidirectional serialize/deserialize numberToSerialize bits to/from the input. | |
| template<class templateType > | |
| void | Write (templateType inTemplateVar) |
| Write any integral type to a bitstream. | |
| template<class templateType > | |
| void | WriteRef (const templateType &inTemplateVar) |
| template<class templateType > | |
| void | WritePtr (templateType *inTemplateVar) |
| Write the dereferenced pointer to any integral type to a bitstream. | |
| template<class templateType > | |
| void | WriteDelta (templateType currentValue, templateType lastValue) |
| Write any integral type to a bitstream. | |
| template<class templateType > | |
| void | WriteDelta (templateType currentValue) |
| WriteDelta when you don't know what the last value is, or there is no last value. | |
| template<class templateType > | |
| void | WriteCompressed (templateType inTemplateVar) |
| Write any integral type to a bitstream. | |
| template<class templateType > | |
| void | WriteCompressedDelta (templateType currentValue, templateType lastValue) |
| Write any integral type to a bitstream. | |
| template<class templateType > | |
| void | WriteCompressedDelta (templateType currentValue) |
| Save as WriteCompressedDelta(templateType currentValue, templateType lastValue) when we have an unknown second parameter. | |
| template<class templateType > | |
| bool | Read (templateType &outTemplateVar) |
| Read any integral type from a bitstream. | |
| template<class templateType > | |
| bool | ReadPtr (templateType *outTemplateVar) |
| Read into a pointer to any integral type from a bitstream. | |
| template<class templateType > | |
| bool | ReadDelta (templateType &outTemplateVar) |
| Read any integral type from a bitstream. | |
| template<class templateType > | |
| bool | ReadCompressed (templateType &outTemplateVar) |
| Read any integral type from a bitstream. | |
| template<class templateType > | |
| bool | ReadCompressedDelta (templateType &outTemplateVar) |
| Read any integral type from a bitstream. | |
| bool | Read (BitStream *bitStream, BitSize_t numberOfBits) |
| Read one bitstream to another. | |
| bool | Read (BitStream *bitStream) |
| bool | Read (BitStream &bitStream, BitSize_t numberOfBits) |
| bool | Read (BitStream &bitStream) |
| void | Write (const char *inputByteArray, const unsigned int numberOfBytes) |
| Write an array or casted stream or raw data. This does NOT do endian swapping. | |
| void | Write (BitStream *bitStream, BitSize_t numberOfBits) |
| Write one bitstream to another. | |
| void | Write (BitStream *bitStream) |
| void | Write (BitStream &bitStream, BitSize_t numberOfBits) |
| void | Write (BitStream &bitStream) |
| void | WriteFloat16 (float x, float floatMin, float floatMax) |
| Write a float into 2 bytes, spanning the range between floatMin and floatMax. | |
| template<class serializationType , class sourceType > | |
| void | WriteCasted (const sourceType &value) |
| template<class templateType , class rangeType > | |
| void | WriteBitsFromIntegerRange (const templateType value, const rangeType minimum, const rangeType maximum, bool allowOutsideRange=false) |
| template<class templateType , class rangeType > | |
| void | WriteBitsFromIntegerRange (const templateType value, const rangeType minimum, const rangeType maximum, const int requiredBits, bool allowOutsideRange=false) |
| template<class templateType > | |
| void | WriteNormVector (templateType x, templateType y, templateType z) |
| Write a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes. | |
| template<class templateType > | |
| void | WriteVector (templateType x, templateType y, templateType z) |
| Write a vector, using 10 bytes instead of 12. | |
| template<class templateType > | |
| void | WriteNormQuat (templateType w, templateType x, templateType y, templateType z) |
| Write a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy. | |
| template<class templateType > | |
| void | WriteOrthMatrix (templateType m00, templateType m01, templateType m02, templateType m10, templateType m11, templateType m12, templateType m20, templateType m21, templateType m22) |
| Write an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each. | |
| bool | Read (char *output, const unsigned int numberOfBytes) |
| Read an array or casted stream of byte. | |
| bool | ReadFloat16 (float &outFloat, float floatMin, float floatMax) |
| Read a float into 2 bytes, spanning the range between floatMin and floatMax. | |
| template<class serializationType , class sourceType > | |
| bool | ReadCasted (sourceType &value) |
| template<class templateType , class rangeType > | |
| bool | ReadBitsFromIntegerRange (templateType &value, const rangeType minimum, const rangeType maximum, bool allowOutsideRange=false) |
| template<class templateType , class rangeType > | |
| bool | ReadBitsFromIntegerRange (templateType &value, const rangeType minimum, const rangeType maximum, const int requiredBits, bool allowOutsideRange=false) |
| template<class templateType > | |
| bool | ReadNormVector (templateType &x, templateType &y, templateType &z) |
| Read a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes. | |
| template<class templateType > | |
| bool | ReadVector (templateType &x, templateType &y, templateType &z) |
| Read 3 floats or doubles, using 10 bytes, where those float or doubles comprise a vector. | |
| template<class templateType > | |
| bool | ReadNormQuat (templateType &w, templateType &x, templateType &y, templateType &z) |
| Read a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. | |
| template<class templateType > | |
| bool | ReadOrthMatrix (templateType &m00, templateType &m01, templateType &m02, templateType &m10, templateType &m11, templateType &m12, templateType &m20, templateType &m21, templateType &m22) |
| Read an orthogonal matrix from a quaternion, reading 3 components of the quaternion in 2 bytes each and extrapolatig the 4th. | |
| void | ResetReadPointer (void) |
| Sets the read pointer back to the beginning of your data. | |
| void | ResetWritePointer (void) |
| Sets the write pointer back to the beginning of your data. | |
| void | AssertStreamEmpty (void) |
| This is good to call when you are done with the stream to make sure you didn't leave any data left over void. | |
| void | PrintBits (char *out) const |
| RAKNET_DEBUG_PRINTF the bits in the stream. Great for debugging. | |
| void | PrintBits (void) const |
| void | PrintHex (char *out) const |
| void | PrintHex (void) const |
| void | IgnoreBits (const BitSize_t numberOfBits) |
| Ignore data we don't intend to read. | |
| void | IgnoreBytes (const unsigned int numberOfBytes) |
| Ignore data we don't intend to read. | |
| void | SetWriteOffset (const BitSize_t offset) |
| Move the write pointer to a position on the array. | |
| BitSize_t | GetNumberOfBitsUsed (void) const |
| Returns the length in bits of the stream. | |
| BitSize_t | GetWriteOffset (void) const |
| BitSize_t | GetNumberOfBytesUsed (void) const |
| Returns the length in bytes of the stream. | |
| BitSize_t | GetReadOffset (void) const |
| Returns the number of bits into the stream that we have read. | |
| void | SetReadOffset (const BitSize_t newReadOffset) |
| Sets the read bit index. | |
| BitSize_t | GetNumberOfUnreadBits (void) const |
| Returns the number of bits left in the stream that haven't been read. | |
| BitSize_t | CopyData (unsigned char **_data) const |
| Makes a copy of the internal data for you _data will point to the stream. Partial bytes are left aligned. | |
| void | SetData (unsigned char *inByteArray) |
| unsigned char * | GetData (void) const |
| void | WriteBits (const unsigned char *inByteArray, BitSize_t numberOfBitsToWrite, const bool rightAlignedBits=true) |
| Write numberToWrite bits from the input source. | |
| void | WriteAlignedBytes (const unsigned char *inByteArray, const unsigned int numberOfBytesToWrite) |
| Align the bitstream to the byte boundary and then write the specified number of bits. | |
| void | EndianSwapBytes (int byteOffset, int length) |
| void | WriteAlignedBytesSafe (const char *inByteArray, const unsigned int inputLength, const unsigned int maxBytesToWrite) |
| Aligns the bitstream, writes inputLength, and writes input. Won't write beyond maxBytesToWrite. | |
| bool | ReadAlignedBytes (unsigned char *inOutByteArray, const unsigned int numberOfBytesToRead) |
| Read bits, starting at the next aligned bits. | |
| bool | ReadAlignedBytesSafe (char *inOutByteArray, int &inputLength, const int maxBytesToRead) |
| Reads what was written by WriteAlignedBytesSafe. | |
| bool | ReadAlignedBytesSafe (char *inOutByteArray, unsigned int &inputLength, const unsigned int maxBytesToRead) |
| bool | ReadAlignedBytesSafeAlloc (char **outByteArray, int &inputLength, const unsigned int maxBytesToRead) |
| Same as ReadAlignedBytesSafe() but allocates the memory for you using new, rather than assuming it is safe to write to. | |
| bool | ReadAlignedBytesSafeAlloc (char **outByteArray, unsigned int &inputLength, const unsigned int maxBytesToRead) |
| void | AlignWriteToByteBoundary (void) |
| Align the next write and/or read to a byte boundary. | |
| void | AlignReadToByteBoundary (void) |
| Align the next write and/or read to a byte boundary. | |
| bool | ReadBits (unsigned char *inOutByteArray, BitSize_t numberOfBitsToRead, const bool alignBitsToRight=true) |
| Read numberOfBitsToRead bits to the output source. | |
| void | Write0 (void) |
| Write a 0. | |
| void | Write1 (void) |
| Write a 1. | |
| bool | ReadBit (void) |
| Reads 1 bit and returns true if that bit is 1 and false if it is 0. | |
| void | AssertCopyData (void) |
| If we used the constructor version with copy data off, this makes sure it is set to on and the data pointed to is copied. | |
| void | SetNumberOfBitsAllocated (const BitSize_t lengthInBits) |
| Use this if you pass a pointer copy to the constructor (_copyData==false) and want to overallocate to prevent reallocation. | |
| void | AddBitsAndReallocate (const BitSize_t numberOfBitsToWrite) |
| Reallocates (if necessary) in preparation of writing numberOfBitsToWrite. | |
| BitSize_t | GetNumberOfBitsAllocated (void) const |
| bool | Read (char *varString) |
| Read strings, non reference. | |
| bool | Read (unsigned char *varString) |
| void | PadWithZeroToByteLength (unsigned int bytes) |
| Write zeros until the bitstream is filled up to bytes. | |
| void | WriteAlignedVar8 (const char *inByteArray) |
| bool | ReadAlignedVar8 (char *inOutByteArray) |
| void | WriteAlignedVar16 (const char *inByteArray) |
| bool | ReadAlignedVar16 (char *inOutByteArray) |
| void | WriteAlignedVar32 (const char *inByteArray) |
| bool | ReadAlignedVar32 (char *inOutByteArray) |
| template<> | |
| void | WriteRef (const bool &inTemplateVar) |
| Write a bool to a bitstream. | |
| template<> | |
| void | WriteRef (const SystemAddress &inTemplateVar) |
| Write a systemAddress to a bitstream. | |
| template<> | |
| void | WriteRef (const uint24_t &inTemplateVar) |
| template<> | |
| void | WriteRef (const RakNetGUID &inTemplateVar) |
| template<> | |
| void | WriteRef (const NetworkID &inTemplateVar) |
| Write an networkID to a bitstream. | |
| template<> | |
| void | WriteRef (const RakString &inTemplateVar) |
| Write a string to a bitstream. | |
| template<> | |
| void | WriteRef (const char *const &inStringVar) |
| template<> | |
| void | WriteRef (const unsigned char *const &inTemplateVar) |
| template<> | |
| void | WriteRef (char *const &inTemplateVar) |
| template<> | |
| void | WriteRef (unsigned char *const &inTemplateVar) |
| template<> | |
| void | WriteDelta (bool currentValue, bool lastValue) |
| Write a bool delta. Same thing as just calling Write. | |
| template<> | |
| void | WriteCompressed (SystemAddress inTemplateVar) |
| template<> | |
| void | WriteCompressed (RakNetGUID inTemplateVar) |
| template<> | |
| void | WriteCompressed (uint24_t var) |
| template<> | |
| void | WriteCompressed (NetworkID inTemplateVar) |
| template<> | |
| void | WriteCompressed (bool inTemplateVar) |
| template<> | |
| void | WriteCompressed (float inTemplateVar) |
| For values between -1 and 1. | |
| template<> | |
| void | WriteCompressed (double inTemplateVar) |
| For values between -1 and 1. | |
| template<> | |
| void | WriteCompressed (RakString inTemplateVar) |
| Compress the string. | |
| template<> | |
| void | WriteCompressed (const char *inStringVar) |
| template<> | |
| void | WriteCompressed (const unsigned char *inTemplateVar) |
| template<> | |
| void | WriteCompressed (char *inTemplateVar) |
| template<> | |
| void | WriteCompressed (unsigned char *inTemplateVar) |
| template<> | |
| void | WriteCompressedDelta (bool currentValue, bool lastValue) |
| Write a bool delta. Same thing as just calling Write. | |
| template<> | |
| void | WriteCompressedDelta (bool currentValue) |
| Save as WriteCompressedDelta(bool currentValue, templateType lastValue) when we have an unknown second bool. | |
| template<> | |
| bool | Read (bool &outTemplateVar) |
| Read a bool from a bitstream. | |
| template<> | |
| bool | Read (SystemAddress &outTemplateVar) |
| Read a systemAddress from a bitstream. | |
| template<> | |
| bool | Read (uint24_t &outTemplateVar) |
| template<> | |
| bool | Read (RakNetGUID &outTemplateVar) |
| template<> | |
| bool | Read (NetworkID &outTemplateVar) |
| Read an networkID from a bitstream. | |
| template<> | |
| bool | Read (RakString &outTemplateVar) |
| Read an networkID from a bitstream. | |
| template<> | |
| bool | Read (char *&varString) |
| template<> | |
| bool | Read (unsigned char *&varString) |
| template<> | |
| bool | ReadDelta (bool &outTemplateVar) |
| Read a bool from a bitstream. | |
| template<> | |
| bool | ReadCompressed (SystemAddress &outTemplateVar) |
| template<> | |
| bool | ReadCompressed (uint24_t &outTemplateVar) |
| template<> | |
| bool | ReadCompressed (RakNetGUID &outTemplateVar) |
| template<> | |
| bool | ReadCompressed (NetworkID &outTemplateVar) |
| template<> | |
| bool | ReadCompressed (bool &outTemplateVar) |
| template<> | |
| bool | ReadCompressed (float &outTemplateVar) |
| For values between -1 and 1. | |
| template<> | |
| bool | ReadCompressed (double &outTemplateVar) |
| For values between -1 and 1. | |
| template<> | |
| bool | ReadCompressed (RakString &outTemplateVar) |
| For strings. | |
| template<> | |
| bool | ReadCompressed (char *&outTemplateVar) |
| template<> | |
| bool | ReadCompressed (unsigned char *&outTemplateVar) |
| template<> | |
| bool | ReadCompressedDelta (bool &outTemplateVar) |
| Read a bool from a bitstream. | |
Static Public Member Functions | |
| static int | NumberOfLeadingZeroes (uint8_t x) |
| static int | NumberOfLeadingZeroes (uint16_t x) |
| static int | NumberOfLeadingZeroes (uint32_t x) |
| static int | NumberOfLeadingZeroes (uint64_t x) |
| static int | NumberOfLeadingZeroes (int8_t x) |
| static int | NumberOfLeadingZeroes (int16_t x) |
| static int | NumberOfLeadingZeroes (int32_t x) |
| static int | NumberOfLeadingZeroes (int64_t x) |
| static bool | DoEndianSwap (void) |
| ---- Member function template specialization declarations ---- | |
| static bool | IsBigEndian (void) |
| static bool | IsNetworkOrder (void) |
| static bool | IsNetworkOrderInternal (void) |
| static void | ReverseBytes (unsigned char *inByteArray, unsigned char *inOutByteArray, const unsigned int length) |
| static void | ReverseBytesInPlace (unsigned char *inOutData, const unsigned int length) |
This class allows you to write and read native types as a string of bits. BitStream is used extensively throughout RakNet and is designed to be used by users as well.
Definition at line 41 of file BitStream.h.
| BitStream::BitStream | ( | ) |
Default Constructor.
Definition at line 48 of file BitStream.cpp.
| BitStream::BitStream | ( | const unsigned int | initialBytesToAllocate | ) |
Create the bitstream, with some number of bytes to immediately allocate.
There is no benefit to calling this, unless you know exactly how many bytes you need and it is greater than BITSTREAM_STACK_ALLOCATION_SIZE. In that case all it does is save you one or more realloc calls.
| [in] | initialBytesToAllocate | the number of bytes to pre-allocate. |
Definition at line 64 of file BitStream.cpp.
| BitStream::BitStream | ( | unsigned char * | _data, | |
| const unsigned int | lengthInBytes, | |||
| bool | _copyData | |||
| ) |
Initialize the BitStream, immediately setting the data it contains to a predefined pointer.
Set _copyData to true if you want to make an internal copy of the data you are passing. Set it to false to just save a pointer to the data. You shouldn't call Write functions with _copyData as false, as this will write to unallocated memory 99% of the time you will use this function to cast Packet::data to a bitstream for reading, in which case you should write something as follows:
RakNet::BitStream bs(packet->data, packet->length, false);
| [in] | _data | An array of bytes. |
| [in] | lengthInBytes | Size of the _data. |
| [in] | _copyData | true or false to make a copy of _data or not. |
Definition at line 85 of file BitStream.cpp.
| BitStream::~BitStream | ( | ) |
Definition at line 126 of file BitStream.cpp.
| void BitStream::AddBitsAndReallocate | ( | const BitSize_t | numberOfBitsToWrite | ) |
Reallocates (if necessary) in preparation of writing numberOfBitsToWrite.
Cap to 1 meg buffer to save on huge allocations
Definition at line 678 of file BitStream.cpp.

| void RakNet::BitStream::AlignReadToByteBoundary | ( | void | ) | [inline] |
Align the next write and/or read to a byte boundary.
This can be used to 'waste' bits to byte align for efficiency reasons It can also be used to force coalesced bitstreams to start on byte boundaries so so WriteAlignedBits and ReadAlignedBits both calculate the same offset when aligning.
Definition at line 595 of file BitStream.h.

| void RakNet::BitStream::AlignWriteToByteBoundary | ( | void | ) | [inline] |
Align the next write and/or read to a byte boundary.
This can be used to 'waste' bits to byte align for efficiency reasons It can also be used to force coalesced bitstreams to start on byte boundaries so so WriteAlignedBits and ReadAlignedBits both calculate the same offset when aligning.
Definition at line 588 of file BitStream.h.

| void BitStream::AssertCopyData | ( | void | ) |
If we used the constructor version with copy data off, this makes sure it is set to on and the data pointed to is copied.
Definition at line 957 of file BitStream.cpp.
| void BitStream::AssertStreamEmpty | ( | void | ) |
This is good to call when you are done with the stream to make sure you didn't leave any data left over void.
Definition at line 821 of file BitStream.cpp.
| BitSize_t BitStream::CopyData | ( | unsigned char ** | _data | ) | const |
Makes a copy of the internal data for you _data will point to the stream. Partial bytes are left aligned.
| [out] | _data | The allocated copy of GetData() |
Definition at line 884 of file BitStream.cpp.

| static bool RakNet::BitStream::DoEndianSwap | ( | void | ) | [inline, static] |
---- Member function template specialization declarations ----
Definition at line 857 of file BitStream.h.

| void BitStream::EndianSwapBytes | ( | int | byteOffset, | |
| int | length | |||
| ) |
| unsigned char* RakNet::BitStream::GetData | ( | void | ) | const [inline] |
Gets the data that BitStream is writing to / reading from. Partial bytes are left aligned.
Definition at line 530 of file BitStream.h.

| BitSize_t BitStream::GetNumberOfBitsAllocated | ( | void | ) | const |
| BitSize_t RakNet::BitStream::GetNumberOfBitsUsed | ( | void | ) | const [inline] |
Returns the length in bits of the stream.
Definition at line 502 of file BitStream.h.

| BitSize_t RakNet::BitStream::GetNumberOfBytesUsed | ( | void | ) | const [inline] |
Returns the length in bytes of the stream.
Definition at line 506 of file BitStream.h.

| BitSize_t RakNet::BitStream::GetNumberOfUnreadBits | ( | void | ) | const [inline] |
Returns the number of bits left in the stream that haven't been read.
Definition at line 515 of file BitStream.h.

| BitSize_t RakNet::BitStream::GetReadOffset | ( | void | ) | const [inline] |
Returns the number of bits into the stream that we have read.
Definition at line 509 of file BitStream.h.

| BitSize_t RakNet::BitStream::GetWriteOffset | ( | void | ) | const [inline] |
| void BitStream::IgnoreBits | ( | const BitSize_t | numberOfBits | ) |
Ignore data we don't intend to read.
| [in] | numberOfBits | The number of bits to ignore |
Definition at line 896 of file BitStream.cpp.

| void BitStream::IgnoreBytes | ( | const unsigned int | numberOfBytes | ) |
Ignore data we don't intend to read.
| [in] | numberOfBits | The number of bytes to ignore |
Definition at line 901 of file BitStream.cpp.


| static bool RakNet::BitStream::IsBigEndian | ( | void | ) | [inline, static] |
| static bool RakNet::BitStream::IsNetworkOrder | ( | void | ) | [inline, static] |
| bool BitStream::IsNetworkOrderInternal | ( | void | ) | [static] |
Definition at line 979 of file BitStream.cpp.
| int BitStream::NumberOfLeadingZeroes | ( | uint16_t | x | ) | [static] |
Definition at line 778 of file BitStream.cpp.
| int BitStream::NumberOfLeadingZeroes | ( | uint32_t | x | ) | [static] |
Definition at line 791 of file BitStream.cpp.
| int BitStream::NumberOfLeadingZeroes | ( | uint64_t | x | ) | [static] |
Definition at line 805 of file BitStream.cpp.
| int BitStream::NumberOfLeadingZeroes | ( | int8_t | x | ) | [static] |
| int BitStream::NumberOfLeadingZeroes | ( | int16_t | x | ) | [static] |
| int BitStream::NumberOfLeadingZeroes | ( | int32_t | x | ) | [static] |
| int BitStream::NumberOfLeadingZeroes | ( | int64_t | x | ) | [static] |
| int BitStream::NumberOfLeadingZeroes | ( | uint8_t | x | ) | [static] |
Get the number of leading zeros for a number
| [in] | x | Number to test |
Definition at line 766 of file BitStream.cpp.

| void BitStream::PadWithZeroToByteLength | ( | unsigned int | bytes | ) |
Write zeros until the bitstream is filled up to bytes.
Definition at line 728 of file BitStream.cpp.


| void BitStream::PrintBits | ( | char * | out | ) | const |
RAKNET_DEBUG_PRINTF the bits in the stream. Great for debugging.
Definition at line 825 of file BitStream.cpp.
| void BitStream::PrintBits | ( | void | ) | const |
Definition at line 861 of file BitStream.cpp.
| void BitStream::PrintHex | ( | char * | out | ) | const |
| void BitStream::PrintHex | ( | void | ) | const |
Definition at line 875 of file BitStream.cpp.
| bool BitStream::Read | ( | BitStream * | bitStream | ) |
| bool BitStream::Read | ( | BitStream & | bitStream | ) |
| bool RakNet::BitStream::Read | ( | bool & | outTemplateVar | ) | [inline] |
Read a bool from a bitstream.
| [in] | outTemplateVar | The value to read |
Definition at line 1537 of file BitStream.h.
| bool RakNet::BitStream::Read | ( | SystemAddress & | outTemplateVar | ) | [inline] |
Read a systemAddress from a bitstream.
| [in] | outTemplateVar | The value to read |
Definition at line 1556 of file BitStream.h.

| bool RakNet::BitStream::Read | ( | uint24_t & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::Read | ( | RakNetGUID & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::Read | ( | NetworkID & | outTemplateVar | ) | [inline] |
Read an networkID from a bitstream.
| [in] | outTemplateVar | The value to read |
Definition at line 1602 of file BitStream.h.

| bool RakNet::BitStream::Read | ( | RakString & | outTemplateVar | ) | [inline] |
Read an networkID from a bitstream.
| [in] | outTemplateVar | The value to read |
Definition at line 1631 of file BitStream.h.

| bool RakNet::BitStream::Read | ( | char *& | varString | ) | [inline] |
| bool RakNet::BitStream::Read | ( | unsigned char *& | varString | ) | [inline] |
| bool BitStream::Read | ( | char * | varString | ) |
Read strings, non reference.
Definition at line 1005 of file BitStream.cpp.

| bool BitStream::Read | ( | char * | output, | |
| const unsigned int | numberOfBytes | |||
| ) |
Read an array or casted stream of byte.
The array is raw data. There is no automatic endian conversion with this function
| [in] | output | The result byte array. It should be larger than numberOfBytes. |
| [in] | numberOfBytes | The number of byte to read |
Definition at line 257 of file BitStream.cpp.

| bool BitStream::Read | ( | unsigned char * | varString | ) |
Read one bitstream to another.
| [in] | numberOfBits | bits to read |
| bitStream | the bitstream to read into from |
Definition at line 231 of file BitStream.cpp.

| bool RakNet::BitStream::Read | ( | templateType & | outTemplateVar | ) | [inline] |
Read any integral type from a bitstream.
Read any integral type from a bitstream. Define __BITSTREAM_NATIVE_END if you need endian swapping.
Define __BITSTREAM_NATIVE_END if you need endian swapping.
| [in] | outTemplateVar | The value to read |
| [in] | outTemplateVar | The value to read |
Definition at line 1475 of file BitStream.h.

| bool BitStream::ReadAlignedBytes | ( | unsigned char * | inOutByteArray, | |
| const unsigned int | numberOfBytesToRead | |||
| ) |
Read bits, starting at the next aligned bits.
Note that the modulus 8 starting offset of the sequence must be the same as was used with WriteBits. This will be a problem with packet coalescence unless you byte align the coalesced packets.
| [in] | inOutByteArray | The byte array larger than numberOfBytesToRead |
| [in] | numberOfBytesToRead | The number of byte to read from the internal state |
Definition at line 354 of file BitStream.cpp.


| bool BitStream::ReadAlignedBytesSafe | ( | char * | inOutByteArray, | |
| unsigned int & | inputLength, | |||
| const unsigned int | maxBytesToRead | |||
| ) |
| bool BitStream::ReadAlignedBytesSafe | ( | char * | inOutByteArray, | |
| int & | inputLength, | |||
| const int | maxBytesToRead | |||
| ) |
Reads what was written by WriteAlignedBytesSafe.
| [in] | inOutByteArray | The data |
| [in] | maxBytesToRead | Maximum number of bytes to read |
Definition at line 376 of file BitStream.cpp.
| bool BitStream::ReadAlignedBytesSafeAlloc | ( | char ** | outByteArray, | |
| int & | inputLength, | |||
| const unsigned int | maxBytesToRead | |||
| ) |
Same as ReadAlignedBytesSafe() but allocates the memory for you using new, rather than assuming it is safe to write to.
| [in] | outByteArray | outByteArray will be deleted if it is not a pointer to 0 |
Definition at line 390 of file BitStream.cpp.

| bool BitStream::ReadAlignedBytesSafeAlloc | ( | char ** | outByteArray, | |
| unsigned int & | inputLength, | |||
| const unsigned int | maxBytesToRead | |||
| ) |
| bool BitStream::ReadAlignedVar16 | ( | char * | inOutByteArray | ) |
| bool BitStream::ReadAlignedVar32 | ( | char * | inOutByteArray | ) |
| bool BitStream::ReadAlignedVar8 | ( | char * | inOutByteArray | ) |
Definition at line 1020 of file BitStream.cpp.
| bool BitStream::ReadBit | ( | void | ) |
Reads 1 bit and returns true if that bit is 1 and false if it is 0.
Definition at line 317 of file BitStream.cpp.

| bool BitStream::ReadBits | ( | unsigned char * | inOutByteArray, | |
| BitSize_t | numberOfBitsToRead, | |||
| const bool | alignBitsToRight = true | |||
| ) |
Read numberOfBitsToRead bits to the output source.
alignBitsToRight should be set to true to convert internal bitstream data to userdata. It should be false if you used WriteBits with rightAlignedBits false
| [in] | inOutByteArray | The resulting bits array |
| [in] | numberOfBitsToRead | The number of bits to read |
| [in] | alignBitsToRight | if true bits will be right aligned. |
Definition at line 536 of file BitStream.cpp.

| bool RakNet::BitStream::ReadBitsFromIntegerRange | ( | templateType & | value, | |
| const rangeType | minimum, | |||
| const rangeType | maximum, | |||
| bool | allowOutsideRange = false | |||
| ) |
Given the minimum and maximum values for an integer type, figure out the minimum number of bits to represent the range Then read only those bits
| [in] | value | Integer value to read, which should be between minimum and maximum |
| [in] | minimum | Minimum value of value |
| [in] | maximum | Maximum value of value |
| [in] | allowOutsideRange | If true, all sends will take an extra bit, however value can deviate from outside minimum and maximum. If false, will assert if the value deviates. This should match the corresponding value passed to Write(). |
Definition at line 1934 of file BitStream.h.


| bool RakNet::BitStream::ReadBitsFromIntegerRange | ( | templateType & | value, | |
| const rangeType | minimum, | |||
| const rangeType | maximum, | |||
| const int | requiredBits, | |||
| bool | allowOutsideRange = false | |||
| ) |
| [in] | requiredBits | Primarily for internal use, called from above function() after calculating number of bits needed to represent maximum-minimum |
Definition at line 1940 of file BitStream.h.

| bool RakNet::BitStream::ReadCasted | ( | sourceType & | value | ) |
Read one type serialized to another (smaller) type, to save bandwidth serializationType should be uint8_t, uint16_t, uint24_t, or uint32_t Example: int num; ReadCasted<uint8_t>(num); would read 1 bytefrom the stream, and put the value in an integer
| [in] | value | The value to write |
Definition at line 1925 of file BitStream.h.

| bool RakNet::BitStream::ReadCompressed | ( | SystemAddress & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | uint24_t & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | RakNetGUID & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | bool & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | float & | outTemplateVar | ) | [inline] |
For values between -1 and 1.
Definition at line 1735 of file BitStream.h.

| bool RakNet::BitStream::ReadCompressed | ( | double & | outTemplateVar | ) | [inline] |
For values between -1 and 1.
Definition at line 1748 of file BitStream.h.

| bool RakNet::BitStream::ReadCompressed | ( | char *& | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | unsigned char *& | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | NetworkID & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | RakString & | outTemplateVar | ) | [inline] |
| bool RakNet::BitStream::ReadCompressed | ( | templateType & | outTemplateVar | ) | [inline] |
Read any integral type from a bitstream.
Undefine __BITSTREAM_NATIVE_END if you need endian swapping. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte
| [in] | outTemplateVar | The value to read |
Undefine __BITSTREAM_NATIVE_END if you need endian swapping. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte
| [in] | outTemplateVar | The value to read |
Definition at line 1677 of file BitStream.h.


| bool RakNet::BitStream::ReadCompressedDelta | ( | bool & | outTemplateVar | ) | [inline] |
Read a bool from a bitstream.
| [in] | outTemplateVar | The value to read |
Definition at line 1799 of file BitStream.h.

| bool RakNet::BitStream::ReadCompressedDelta | ( | templateType & | outTemplateVar | ) | [inline] |
Read any integral type from a bitstream.
If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. the current value will be updated. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte ReadCompressedDelta is only valid from a previous call to WriteDelta
| [in] | outTemplateVar | The value to read |
If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. the current value will be updated. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte ReadCompressedDelta is only valid from a previous call to WriteDelta
| [in] | outTemplateVar | The value to read |
Definition at line 1786 of file BitStream.h.


| bool RakNet::BitStream::ReadDelta | ( | bool & | outTemplateVar | ) | [inline] |
Read a bool from a bitstream.
| [in] | outTemplateVar | The value to read |
Definition at line 1665 of file BitStream.h.

| bool RakNet::BitStream::ReadDelta | ( | templateType & | outTemplateVar | ) | [inline] |
Read any integral type from a bitstream.
If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. ReadDelta is only valid from a previous call to WriteDelta
| [in] | outTemplateVar | The value to read |
If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. ReadDelta is only valid from a previous call to WriteDelta
| [in] | outTemplateVar | The value to read |
Definition at line 1652 of file BitStream.h.


| bool BitStream::ReadFloat16 | ( | float & | outFloat, | |
| float | floatMin, | |||
| float | floatMax | |||
| ) |
Read a float into 2 bytes, spanning the range between floatMin and floatMax.
| [in] | outFloat | The float to read |
| [in] | floatMin | Predetermined minimum value of f |
| [in] | floatMax | Predetermined maximum value of f |
Definition at line 1118 of file BitStream.cpp.


| bool RakNet::BitStream::ReadNormQuat | ( | templateType & | w, | |
| templateType & | x, | |||
| templateType & | y, | |||
| templateType & | z | |||
| ) |
Read a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes.
| [in] | w | w |
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 2016 of file BitStream.h.


| bool RakNet::BitStream::ReadNormVector | ( | templateType & | x, | |
| templateType & | y, | |||
| templateType & | z | |||
| ) |
Read a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes.
Will further compress y or z axis aligned vectors. Accurate to 1/32767.5.
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 1966 of file BitStream.h.


| bool RakNet::BitStream::ReadOrthMatrix | ( | templateType & | m00, | |
| templateType & | m01, | |||
| templateType & | m02, | |||
| templateType & | m10, | |||
| templateType & | m11, | |||
| templateType & | m12, | |||
| templateType & | m20, | |||
| templateType & | m21, | |||
| templateType & | m22 | |||
| ) |
Read an orthogonal matrix from a quaternion, reading 3 components of the quaternion in 2 bytes each and extrapolatig the 4th.
Use 6 bytes instead of 36 Lossy, although the result is renormalized
Definition at line 2047 of file BitStream.h.


| bool RakNet::BitStream::ReadPtr | ( | templateType * | outTemplateVar | ) | [inline] |
Read into a pointer to any integral type from a bitstream.
Define __BITSTREAM_NATIVE_END if you need endian swapping.
| [in] | outTemplateVar | The value to read |
Definition at line 1505 of file BitStream.h.

| bool RakNet::BitStream::ReadVector | ( | templateType & | x, | |
| templateType & | y, | |||
| templateType & | z | |||
| ) |
Read 3 floats or doubles, using 10 bytes, where those float or doubles comprise a vector.
Loses accuracy to about 3/10ths and only saves 2 bytes, so only use if accuracy is not important.
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 1979 of file BitStream.h.


| void BitStream::Reset | ( | void | ) |
Resets the bitstream for reuse.
Definition at line 132 of file BitStream.cpp.

| void BitStream::ResetReadPointer | ( | void | ) |
Sets the read pointer back to the beginning of your data.
Definition at line 278 of file BitStream.cpp.

| void BitStream::ResetWritePointer | ( | void | ) |
Sets the write pointer back to the beginning of your data.
Definition at line 284 of file BitStream.cpp.

| void BitStream::ReverseBytes | ( | unsigned char * | inByteArray, | |
| unsigned char * | inOutByteArray, | |||
| const unsigned int | length | |||
| ) | [static] |
| void BitStream::ReverseBytesInPlace | ( | unsigned char * | inOutData, | |
| const unsigned int | length | |||
| ) | [static] |
| bool RakNet::BitStream::Serialize | ( | bool | writeToBitstream, | |
| char * | inOutByteArray, | |||
| const unsigned int | numberOfBytes | |||
| ) | [inline] |
Bidirectional serialize/deserialize an array or casted stream or raw data. This does NOT do endian swapping.
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutByteArray | a byte buffer |
| [in] | numberOfBytes | the size of input in bytes |
Definition at line 963 of file BitStream.h.

| bool RakNet::BitStream::Serialize | ( | bool | writeToBitstream, | |
| templateType & | inOutTemplateVar | |||
| ) | [inline] |
Bidirectional serialize/deserialize any integral type to/from a bitstream.
Undefine __BITSTREAM_NATIVE_END if you need endian swapping.
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutTemplateVar | The value to write |
Definition at line 904 of file BitStream.h.


| bool RakNet::BitStream::SerializeBits | ( | bool | writeToBitstream, | |
| unsigned char * | inOutByteArray, | |||
| const BitSize_t | numberOfBitsToSerialize, | |||
| const bool | rightAlignedBits = true | |||
| ) | [inline] |
Bidirectional serialize/deserialize numberToSerialize bits to/from the input.
Right aligned data means in the case of a partial byte, the bits are aligned from the right (bit 0) rather than the left (as in the normal internal representation) You would set this to true when writing user data, and false when copying bitstream data, such as writing one bitstream to another
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutByteArray | The data |
| [in] | numberOfBitsToSerialize | The number of bits to write |
| [in] | rightAlignedBits | if true data will be right aligned |
Definition at line 1038 of file BitStream.h.

| bool RakNet::BitStream::SerializeBitsFromIntegerRange | ( | bool | writeToBitstream, | |
| templateType & | value, | |||
| const rangeType | minimum, | |||
| const rangeType | maximum, | |||
| bool | allowOutsideRange = false | |||
| ) |
Given the minimum and maximum values for an integer type, figure out the minimum number of bits to represent the range Then serialize only those bits
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | value | Integer value to write, which should be between minimum and maximum |
| [in] | minimum | Minimum value of value |
| [in] | maximum | Maximum value of value |
| [in] | allowOutsideRange | If true, all sends will take an extra bit, however value can deviate from outside minimum and maximum. If false, will assert if the value deviates |
Definition at line 981 of file BitStream.h.

| bool RakNet::BitStream::SerializeBitsFromIntegerRange | ( | bool | writeToBitstream, | |
| templateType & | value, | |||
| const rangeType | minimum, | |||
| const rangeType | maximum, | |||
| const int | requiredBits, | |||
| bool | allowOutsideRange = false | |||
| ) |
| [in] | requiredBits | Primarily for internal use, called from above function() after calculating number of bits needed to represent maximum-minimum |
Definition at line 987 of file BitStream.h.

| bool RakNet::BitStream::SerializeCasted | ( | bool | writeToBitstream, | |
| sourceType & | value | |||
| ) |
Serialize one type casted to another (smaller) type, to save bandwidth serializationType should be uint8_t, uint16_t, uint24_t, or uint32_t Example: int num=53; SerializeCasted<uint8_t>(true, num); would use 1 byte to write what would otherwise be an integer (4 or 8 bytes)
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | value | The value to serialize |
Definition at line 973 of file BitStream.h.
| bool RakNet::BitStream::SerializeCompressed | ( | bool | writeToBitstream, | |
| templateType & | inOutTemplateVar | |||
| ) | [inline] |
Bidirectional serialize/deserialize any integral type to/from a bitstream.
Undefine __BITSTREAM_NATIVE_END if you need endian swapping. If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutTemplateVar | The value to write |
Definition at line 934 of file BitStream.h.


| bool RakNet::BitStream::SerializeCompressedDelta | ( | bool | writeToBitstream, | |
| templateType & | inOutCurrentValue, | |||
| templateType | lastValue | |||
| ) | [inline] |
Bidirectional serialize/deserialize any integral type to/from a bitstream.
If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutCurrentValue | The current value to write |
| [in] | lastValue | The last value to compare against. Only used if writeToBitstream is true. |
Definition at line 944 of file BitStream.h.

| bool RakNet::BitStream::SerializeCompressedDelta | ( | bool | writeToBitstream, | |
| templateType & | inOutTemplateVar | |||
| ) | [inline] |
Save as SerializeCompressedDelta(templateType ¤tValue, templateType lastValue) when we have an unknown second parameter.
Definition at line 954 of file BitStream.h.

| bool RakNet::BitStream::SerializeDelta | ( | bool | writeToBitstream, | |
| templateType & | inOutCurrentValue | |||
| ) | [inline] |
Bidirectional version of SerializeDelta when you don't know what the last value is, or there is no last value.
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutCurrentValue | The current value to write |
Definition at line 924 of file BitStream.h.

| bool RakNet::BitStream::SerializeDelta | ( | bool | writeToBitstream, | |
| templateType & | inOutCurrentValue, | |||
| templateType | lastValue | |||
| ) | [inline] |
Bidirectional serialize/deserialize any integral type to/from a bitstream.
If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutCurrentValue | The current value to write |
| [in] | lastValue | The last value to compare against. Only used if writeToBitstream is true. |
Definition at line 914 of file BitStream.h.

| bool BitStream::SerializeFloat16 | ( | bool | writeToBitstream, | |
| float & | inOutFloat, | |||
| float | floatMin, | |||
| float | floatMax | |||
| ) |
Serialize a float into 2 bytes, spanning the range between floatMin and floatMax.
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | inOutFloat | The float to write |
| [in] | floatMin | Predetermined minimum value of f |
| [in] | floatMax | Predetermined maximum value of f |
Definition at line 1133 of file BitStream.cpp.

| bool RakNet::BitStream::SerializeNormQuat | ( | bool | writeToBitstream, | |
| templateType & | w, | |||
| templateType & | x, | |||
| templateType & | y, | |||
| templateType & | z | |||
| ) | [inline] |
Bidirectional serialize/deserialize a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy.
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | w | w |
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 1015 of file BitStream.h.

| bool RakNet::BitStream::SerializeNormVector | ( | bool | writeToBitstream, | |
| templateType & | x, | |||
| templateType & | y, | |||
| templateType & | z | |||
| ) | [inline] |
Bidirectional serialize/deserialize a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes.
Will further compress y or z axis aligned vectors. Accurate to 1/32767.5.
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 995 of file BitStream.h.

| bool RakNet::BitStream::SerializeOrthMatrix | ( | bool | writeToBitstream, | |
| templateType & | m00, | |||
| templateType & | m01, | |||
| templateType & | m02, | |||
| templateType & | m10, | |||
| templateType & | m11, | |||
| templateType & | m12, | |||
| templateType & | m20, | |||
| templateType & | m21, | |||
| templateType & | m22 | |||
| ) | [inline] |
Bidirectional serialize/deserialize an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each.
Use 6 bytes instead of 36 Lossy, although the result is renormalized
Definition at line 1025 of file BitStream.h.

| bool RakNet::BitStream::SerializeVector | ( | bool | writeToBitstream, | |
| templateType & | x, | |||
| templateType & | y, | |||
| templateType & | z | |||
| ) | [inline] |
Bidirectional serialize/deserialize a vector, using 10 bytes instead of 12.
Loses accuracy to about 3/10ths and only saves 2 bytes, so only use if accuracy is not important.
| [in] | writeToBitstream | true to write from your data to this bitstream. False to read from this bitstream and write to your data |
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 1005 of file BitStream.h.

| void BitStream::SetData | ( | unsigned char * | inByteArray | ) |
Definition at line 467 of file BitStream.cpp.
| void BitStream::SetNumberOfBitsAllocated | ( | const BitSize_t | lengthInBits | ) |
Use this if you pass a pointer copy to the constructor (_copyData==false) and want to overallocate to prevent reallocation.
Definition at line 118 of file BitStream.cpp.
| void RakNet::BitStream::SetReadOffset | ( | const BitSize_t | newReadOffset | ) | [inline] |
Sets the read bit index.
Definition at line 512 of file BitStream.h.

| void BitStream::SetWriteOffset | ( | const BitSize_t | offset | ) |
Move the write pointer to a position on the array.
| [in] | offset | the offset from the start of the array. |
Dangerous if you don't know what you are doing! For efficiency reasons you can only write mid-stream if your data is byte aligned.
Definition at line 908 of file BitStream.cpp.

| void BitStream::Write | ( | BitStream & | bitStream | ) |
| void BitStream::Write | ( | BitStream * | bitStream | ) |
| void RakNet::BitStream::Write | ( | templateType | inTemplateVar | ) | [inline] |
Write any integral type to a bitstream.
Undefine __BITSTREAM_NATIVE_END if you need endian swapping.
| [in] | inTemplateVar | The value to write |
Definition at line 1048 of file BitStream.h.

| void BitStream::Write | ( | const char * | inputByteArray, | |
| const unsigned int | numberOfBytes | |||
| ) |
Write an array or casted stream or raw data. This does NOT do endian swapping.
| [in] | inputByteArray | a byte buffer |
| [in] | numberOfBytes | the size of input in bytes |
Definition at line 156 of file BitStream.cpp.

Write one bitstream to another.
| [in] | numberOfBits | bits to write |
| bitStream | the bitstream to copy from |
Definition at line 178 of file BitStream.cpp.

| void BitStream::Write0 | ( | void | ) |
Write a 0.
Definition at line 290 of file BitStream.cpp.


| void BitStream::Write1 | ( | void | ) |
Write a 1.
Definition at line 302 of file BitStream.cpp.


| void BitStream::WriteAlignedBytes | ( | const unsigned char * | inByteArray, | |
| const unsigned int | numberOfBytesToWrite | |||
| ) |
Align the bitstream to the byte boundary and then write the specified number of bits.
This is faster than WriteBits but wastes the bits to do the alignment and requires you to call ReadAlignedBits at the corresponding read position.
| [in] | inByteArray | The data |
| [in] | numberOfBytesToWrite | The size of input. |
Definition at line 327 of file BitStream.cpp.


| void BitStream::WriteAlignedBytesSafe | ( | const char * | inByteArray, | |
| const unsigned int | inputLength, | |||
| const unsigned int | maxBytesToWrite | |||
| ) |
Aligns the bitstream, writes inputLength, and writes input. Won't write beyond maxBytesToWrite.
| [in] | inByteArray | The data |
| [in] | inputLength | The size of input. |
| [in] | maxBytesToWrite | Max bytes to write |
Definition at line 340 of file BitStream.cpp.


| void BitStream::WriteAlignedVar16 | ( | const char * | inByteArray | ) |
| void BitStream::WriteAlignedVar32 | ( | const char * | inByteArray | ) |
| void BitStream::WriteAlignedVar8 | ( | const char * | inByteArray | ) |
| void BitStream::WriteBits | ( | const unsigned char * | inByteArray, | |
| BitSize_t | numberOfBitsToWrite, | |||
| const bool | rightAlignedBits = true | |||
| ) |
Write numberToWrite bits from the input source.
Right aligned data means in the case of a partial byte, the bits are aligned from the right (bit 0) rather than the left (as in the normal internal representation) You would set this to true when writing user data, and false when copying bitstream data, such as writing one bitstream to another.
| [in] | inByteArray | The data |
| [in] | numberOfBitsToWrite | The number of bits to write |
| [in] | rightAlignedBits | if true data will be right aligned |
Definition at line 409 of file BitStream.cpp.


| void RakNet::BitStream::WriteBitsFromIntegerRange | ( | const templateType | value, | |
| const rangeType | minimum, | |||
| const rangeType | maximum, | |||
| bool | allowOutsideRange = false | |||
| ) |
Given the minimum and maximum values for an integer type, figure out the minimum number of bits to represent the range Then write only those bits
| [in] | value | Integer value to write, which should be between minimum and maximum |
| [in] | minimum | Minimum value of value |
| [in] | maximum | Maximum value of value |
| [in] | allowOutsideRange | If true, all sends will take an extra bit, however value can deviate from outside minimum and maximum. If false, will assert if the value deviates. This should match the corresponding value passed to Read(). |
Definition at line 1812 of file BitStream.h.


| void RakNet::BitStream::WriteBitsFromIntegerRange | ( | const templateType | value, | |
| const rangeType | minimum, | |||
| const rangeType | maximum, | |||
| const int | requiredBits, | |||
| bool | allowOutsideRange = false | |||
| ) |
| [in] | requiredBits | Primarily for internal use, called from above function() after calculating number of bits needed to represent maximum-minimum |
Definition at line 1818 of file BitStream.h.

| void RakNet::BitStream::WriteCasted | ( | const sourceType & | value | ) |
Write one type serialized as another (smaller) type, to save bandwidth serializationType should be uint8_t, uint16_t, uint24_t, or uint32_t Example: int num=53; WriteCasted<uint8_t>(num); would use 1 byte to write what would otherwise be an integer (4 or 8 bytes)
| [in] | value | The value to write |
Definition at line 1805 of file BitStream.h.

| void RakNet::BitStream::WriteCompressed | ( | const unsigned char * | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | SystemAddress | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | double | inTemplateVar | ) | [inline] |
For values between -1 and 1.
Definition at line 1382 of file BitStream.h.

| void RakNet::BitStream::WriteCompressed | ( | unsigned char * | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | RakNetGUID | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | char * | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | uint24_t | var | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | RakString | inTemplateVar | ) | [inline] |
Compress the string.
Definition at line 1397 of file BitStream.h.

| void RakNet::BitStream::WriteCompressed | ( | float | inTemplateVar | ) | [inline] |
For values between -1 and 1.
Definition at line 1370 of file BitStream.h.

| void RakNet::BitStream::WriteCompressed | ( | templateType | inTemplateVar | ) | [inline] |
Write any integral type to a bitstream.
Undefine __BITSTREAM_NATIVE_END if you need endian swapping. If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type
| [in] | inTemplateVar | The value to write |
Undefine __BITSTREAM_NATIVE_END if you need endian swapping. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte
| [in] | inTemplateVar | The value to write |
Definition at line 1312 of file BitStream.h.


| void RakNet::BitStream::WriteCompressed | ( | const char * | inStringVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | bool | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressed | ( | NetworkID | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteCompressedDelta | ( | templateType | currentValue, | |
| templateType | lastValue | |||
| ) | [inline] |
Write any integral type to a bitstream.
If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte
| [in] | currentValue | The current value to write |
| [in] | lastValue | The last value to compare against |
Definition at line 1431 of file BitStream.h.


| void RakNet::BitStream::WriteCompressedDelta | ( | bool | currentValue, | |
| bool | lastValue | |||
| ) | [inline] |
Write a bool delta. Same thing as just calling Write.
| [in] | currentValue | The current value to write |
| [in] | lastValue | The last value to compare against |
Definition at line 1448 of file BitStream.h.

| void RakNet::BitStream::WriteCompressedDelta | ( | templateType | currentValue | ) | [inline] |
Save as WriteCompressedDelta(templateType currentValue, templateType lastValue) when we have an unknown second parameter.
Definition at line 1458 of file BitStream.h.

| void RakNet::BitStream::WriteCompressedDelta | ( | bool | currentValue | ) | [inline] |
Save as WriteCompressedDelta(bool currentValue, templateType lastValue) when we have an unknown second bool.
Definition at line 1467 of file BitStream.h.

| void RakNet::BitStream::WriteDelta | ( | templateType | currentValue | ) | [inline] |
WriteDelta when you don't know what the last value is, or there is no last value.
| [in] | currentValue | The current value to write |
Definition at line 1299 of file BitStream.h.

| void RakNet::BitStream::WriteDelta | ( | bool | currentValue, | |
| bool | lastValue | |||
| ) | [inline] |
Write a bool delta. Same thing as just calling Write.
| [in] | currentValue | The current value to write |
| [in] | lastValue | The last value to compare against |
Definition at line 1289 of file BitStream.h.

| void RakNet::BitStream::WriteDelta | ( | templateType | currentValue, | |
| templateType | lastValue | |||
| ) | [inline] |
Write any integral type to a bitstream.
If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written
| [in] | currentValue | The current value to write |
| [in] | lastValue | The last value to compare against |
Definition at line 1218 of file BitStream.h.


| void BitStream::WriteFloat16 | ( | float | x, | |
| float | floatMin, | |||
| float | floatMax | |||
| ) |
Write a float into 2 bytes, spanning the range between floatMin and floatMax.
| [in] | x | The float to write |
| [in] | floatMin | Predetermined minimum value of f |
| [in] | floatMax | Predetermined maximum value of f |
Definition at line 1141 of file BitStream.cpp.


| void RakNet::BitStream::WriteNormQuat | ( | templateType | w, | |
| templateType | x, | |||
| templateType | y, | |||
| templateType | z | |||
| ) |
Write a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy.
| [in] | w | w |
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 1874 of file BitStream.h.


| void RakNet::BitStream::WriteNormVector | ( | templateType | x, | |
| templateType | y, | |||
| templateType | z | |||
| ) |
Write a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes.
Will further compress y or z axis aligned vectors. Accurate to 1/32767.5.
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 1846 of file BitStream.h.


| void RakNet::BitStream::WriteOrthMatrix | ( | templateType | m00, | |
| templateType | m01, | |||
| templateType | m02, | |||
| templateType | m10, | |||
| templateType | m11, | |||
| templateType | m12, | |||
| templateType | m20, | |||
| templateType | m21, | |||
| templateType | m22 | |||
| ) |
Write an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each.
Use 6 bytes instead of 36 Lossy, although the result is renormalized
Definition at line 1887 of file BitStream.h.


| void RakNet::BitStream::WritePtr | ( | templateType * | inTemplateVar | ) | [inline] |
Write the dereferenced pointer to any integral type to a bitstream.
Undefine __BITSTREAM_NATIVE_END if you need endian swapping.
| [in] | inTemplateVar | The value to write |
Definition at line 1077 of file BitStream.h.

| void RakNet::BitStream::WriteRef | ( | const char *const & | inStringVar | ) | [inline] |
| void RakNet::BitStream::WriteRef | ( | const unsigned char *const & | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteRef | ( | const bool & | inTemplateVar | ) | [inline] |
Write a bool to a bitstream.
| [in] | inTemplateVar | The value to write |
Definition at line 1102 of file BitStream.h.

| void RakNet::BitStream::WriteRef | ( | const uint24_t & | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteRef | ( | const SystemAddress & | inTemplateVar | ) | [inline] |
Write a systemAddress to a bitstream.
| [in] | inTemplateVar | The value to write |
Definition at line 1114 of file BitStream.h.

| void RakNet::BitStream::WriteRef | ( | const NetworkID & | inTemplateVar | ) | [inline] |
Write an networkID to a bitstream.
| [in] | inTemplateVar | The value to write |
Definition at line 1155 of file BitStream.h.

| void RakNet::BitStream::WriteRef | ( | const RakString & | inTemplateVar | ) | [inline] |
Write a string to a bitstream.
| [in] | var | The value to write |
Definition at line 1187 of file BitStream.h.

| void RakNet::BitStream::WriteRef | ( | unsigned char *const & | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteRef | ( | char *const & | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteRef | ( | const RakNetGUID & | inTemplateVar | ) | [inline] |
| void RakNet::BitStream::WriteRef | ( | const templateType & | inTemplateVar | ) | [inline] |
Definition at line 1054 of file BitStream.h.


| void RakNet::BitStream::WriteVector | ( | templateType | x, | |
| templateType | y, | |||
| templateType | z | |||
| ) |
Write a vector, using 10 bytes instead of 12.
Loses accuracy to about 3/10ths and only saves 2 bytes, so only use if accuracy is not important.
| [in] | x | x |
| [in] | y | y |
| [in] | z | z |
Definition at line 1858 of file BitStream.h.


1.7.1