From 75bf194b2fca06de805a7bc025c6dd8379250fa5 Mon Sep 17 00:00:00 2001 From: Northstar Date: Thu, 3 Feb 2022 22:09:08 -0300 Subject: Format project --- NorthstarDedicatedTest/bitbuf.h | 2017 ++++++++++++++++++++------------------- 1 file changed, 1018 insertions(+), 999 deletions(-) (limited to 'NorthstarDedicatedTest/bitbuf.h') diff --git a/NorthstarDedicatedTest/bitbuf.h b/NorthstarDedicatedTest/bitbuf.h index 7ee0df2a..902a9976 100644 --- a/NorthstarDedicatedTest/bitbuf.h +++ b/NorthstarDedicatedTest/bitbuf.h @@ -4,44 +4,15 @@ #define BITS_PER_INT 32 -INLINE int GetBitForBitnum(int bitNum) { - static int bitsForBitnum[] = - { - (1 << 0), - (1 << 1), - (1 << 2), - (1 << 3), - (1 << 4), - (1 << 5), - (1 << 6), - (1 << 7), - (1 << 8), - (1 << 9), - (1 << 10), - (1 << 11), - (1 << 12), - (1 << 13), - (1 << 14), - (1 << 15), - (1 << 16), - (1 << 17), - (1 << 18), - (1 << 19), - (1 << 20), - (1 << 21), - (1 << 22), - (1 << 23), - (1 << 24), - (1 << 25), - (1 << 26), - (1 << 27), - (1 << 28), - (1 << 29), - (1 << 30), - (1 << 31), - }; - - return bitsForBitnum[(bitNum) & (BITS_PER_INT - 1)]; +INLINE int GetBitForBitnum(int bitNum) +{ + static int bitsForBitnum[] = { + (1 << 0), (1 << 1), (1 << 2), (1 << 3), (1 << 4), (1 << 5), (1 << 6), (1 << 7), (1 << 8), (1 << 9), (1 << 10), + (1 << 11), (1 << 12), (1 << 13), (1 << 14), (1 << 15), (1 << 16), (1 << 17), (1 << 18), (1 << 19), (1 << 20), (1 << 21), + (1 << 22), (1 << 23), (1 << 24), (1 << 25), (1 << 26), (1 << 27), (1 << 28), (1 << 29), (1 << 30), (1 << 31), + }; + + return bitsForBitnum[(bitNum) & (BITS_PER_INT - 1)]; } #undef BITS_PER_INT @@ -61,994 +32,1042 @@ using iptr = intptr_t; // Endianess, don't use on PPC64 nor ARM64BE #define LittleDWord(val) (val) -static INLINE void StoreLittleDWord(u32* base, size_t dwordIndex, u32 dword) { - base[dwordIndex] = LittleDWord(dword); -} +static INLINE void StoreLittleDWord(u32* base, size_t dwordIndex, u32 dword) { base[dwordIndex] = LittleDWord(dword); } -static INLINE u32 LoadLittleDWord(u32* base, size_t dwordIndex) { - return LittleDWord(base[dwordIndex]); -} +static INLINE u32 LoadLittleDWord(u32* base, size_t dwordIndex) { return LittleDWord(base[dwordIndex]); } #include static inline const u32 s_nMaskTable[33] = { - 0, - (1 << 1) - 1, - (1 << 2) - 1, - (1 << 3) - 1, - (1 << 4) - 1, - (1 << 5) - 1, - (1 << 6) - 1, - (1 << 7) - 1, - (1 << 8) - 1, - (1 << 9) - 1, - (1 << 10) - 1, - (1 << 11) - 1, - (1 << 12) - 1, - (1 << 13) - 1, - (1 << 14) - 1, - (1 << 15) - 1, - (1 << 16) - 1, - (1 << 17) - 1, - (1 << 18) - 1, - (1 << 19) - 1, - (1 << 20) - 1, - (1 << 21) - 1, - (1 << 22) - 1, - (1 << 23) - 1, - (1 << 24) - 1, - (1 << 25) - 1, - (1 << 26) - 1, - (1 << 27) - 1, - (1 << 28) - 1, - (1 << 29) - 1, - (1 << 30) - 1, - 0x7fffffff, - 0xffffffff, + 0, + (1 << 1) - 1, + (1 << 2) - 1, + (1 << 3) - 1, + (1 << 4) - 1, + (1 << 5) - 1, + (1 << 6) - 1, + (1 << 7) - 1, + (1 << 8) - 1, + (1 << 9) - 1, + (1 << 10) - 1, + (1 << 11) - 1, + (1 << 12) - 1, + (1 << 13) - 1, + (1 << 14) - 1, + (1 << 15) - 1, + (1 << 16) - 1, + (1 << 17) - 1, + (1 << 18) - 1, + (1 << 19) - 1, + (1 << 20) - 1, + (1 << 21) - 1, + (1 << 22) - 1, + (1 << 23) - 1, + (1 << 24) - 1, + (1 << 25) - 1, + (1 << 26) - 1, + (1 << 27) - 1, + (1 << 28) - 1, + (1 << 29) - 1, + (1 << 30) - 1, + 0x7fffffff, + 0xffffffff, }; -enum EBitCoordType { - kCW_None, - kCW_LowPrecision, - kCW_Integral +enum EBitCoordType +{ + kCW_None, + kCW_LowPrecision, + kCW_Integral }; -class BitBufferBase { -protected: - INLINE void SetName(const char* name) { m_BufferName = name; } +class BitBufferBase +{ + protected: + INLINE void SetName(const char* name) { m_BufferName = name; } -public: - INLINE bool IsOverflowed() { return m_Overflow; } - INLINE void SetOverflowed() { m_Overflow = true; } + public: + INLINE bool IsOverflowed() { return m_Overflow; } + INLINE void SetOverflowed() { m_Overflow = true; } - INLINE const char* GetName() { return m_BufferName; } + INLINE const char* GetName() { return m_BufferName; } -private: - const char* m_BufferName = ""; + private: + const char* m_BufferName = ""; -protected: - u8 m_Overflow = false; + protected: + u8 m_Overflow = false; }; -class BFRead : public BitBufferBase { -public: - BFRead() = default; - - INLINE BFRead(uptr data, size_t byteLength, size_t startPos = 0, const char* bufferName = 0) { - StartReading(data, byteLength, startPos); - - if (bufferName) - SetName(bufferName); - } - -public: - INLINE void StartReading(uptr data, size_t byteLength, size_t startPos = 0) { - m_Data = reinterpret_cast(data); - m_DataIn = m_Data; - - m_DataBytes = byteLength; - m_DataBits = byteLength << 3; - - m_DataEnd = reinterpret_cast(reinterpret_cast(m_Data) + m_DataBytes); - - Seek(startPos); - } - - INLINE void GrabNextDWord(bool overflow = false) { - if (m_Data == m_DataEnd) { - m_CachedBitsLeft = 1; - m_CachedBufWord = 0; - - m_DataIn++; - - if (overflow) - SetOverflowed(); - } - else { - if (m_DataIn > m_DataEnd) { - SetOverflowed(); - m_CachedBufWord = 0; - } - else { - m_CachedBufWord = LittleDWord(*(m_DataIn++)); - } - } - } - - INLINE void FetchNext() { - m_CachedBitsLeft = 32; - GrabNextDWord(false); - } - - INLINE i32 ReadOneBit() { - i32 ret = m_CachedBufWord & 1; - - if (--m_CachedBitsLeft == 0) - FetchNext(); - else - m_CachedBufWord >>= 1; - - return ret; - } - - INLINE u32 ReadUBitLong(i32 numBits) { - if (m_CachedBitsLeft >= numBits) { - u32 ret = m_CachedBufWord & s_nMaskTable[numBits]; - - m_CachedBitsLeft -= numBits; - - if (m_CachedBitsLeft) - m_CachedBufWord >>= numBits; - else - FetchNext(); - - return ret; - } - else { - // need to merge words - u32 ret = m_CachedBufWord; - numBits -= m_CachedBitsLeft; - - GrabNextDWord(true); - - if (IsOverflowed()) - return 0; - - ret |= ((m_CachedBufWord & s_nMaskTable[numBits]) << m_CachedBitsLeft); - - m_CachedBitsLeft = 32 - numBits; - m_CachedBufWord >>= numBits; - - return ret; - } - } - - INLINE i32 ReadSBitLong(int numBits) { - i32 ret = ReadUBitLong(numBits); - return (ret << (32 - numBits)) >> (32 - numBits); - } - - INLINE u32 ReadUBitVar() { - u32 ret = ReadUBitLong(6); - - switch (ret & (16 | 32)) { - case 16: - ret = (ret & 15) | (ReadUBitLong(4) << 4); - // Assert(ret >= 16); - break; - case 32: - ret = (ret & 15) | (ReadUBitLong(8) << 4); - // Assert(ret >= 256); - break; - case 48: - ret = (ret & 15) | (ReadUBitLong(32 - 4) << 4); - // Assert(ret >= 4096); - break; - } - - return ret; - } - - INLINE u32 PeekUBitLong(i32 numBits) { - i32 nSaveBA = m_CachedBitsLeft; - i32 nSaveW = m_CachedBufWord; - u32 const* pSaveP = m_DataIn; - u32 nRet = ReadUBitLong(numBits); - - m_CachedBitsLeft = nSaveBA; - m_CachedBufWord = nSaveW; - m_DataIn = pSaveP; - - return nRet; - } - - INLINE float ReadBitFloat() { - u32 value = ReadUBitLong(32); - return *reinterpret_cast(&value); - } - - /*INLINE float ReadBitCoord() { - i32 intval = 0, fractval = 0, signbit = 0; - float value = 0.0; - - // Read the required integer and fraction flags - intval = ReadOneBit(); - fractval = ReadOneBit(); - - // If we got either parse them, otherwise it's a zero. - if (intval || fractval) { - // Read the sign bit - signbit = ReadOneBit(); - - // If there's an integer, read it in - if (intval) { - // Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE] - intval = ReadUBitLong(COORD_INTEGER_BITS) + 1; - } - - // If there's a fraction, read it in - if (fractval) { - fractval = ReadUBitLong(COORD_FRACTIONAL_BITS); - } - - // Calculate the correct floating point value - value = intval + ((float)fractval * COORD_RESOLUTION); - - // Fixup the sign if negative. - if (signbit) - value = -value; - } - - return value; - } - - INLINE float ReadBitCoordMP() { - i32 intval = 0, fractval = 0, signbit = 0; - float value = 0.0; - - bool inBounds = ReadOneBit() ? true : false; - - // Read the required integer and fraction flags - intval = ReadOneBit(); - - // If we got either parse them, otherwise it's a zero. - if (intval) { - // Read the sign bit - signbit = ReadOneBit(); - - // If there's an integer, read it in - // Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE] - if (inBounds) - value = ReadUBitLong(COORD_INTEGER_BITS_MP) + 1; - else - value = ReadUBitLong(COORD_INTEGER_BITS) + 1; - } - - // Fixup the sign if negative. - if (signbit) - value = -value; - - return value; - } - - INLINE float ReadBitCellCoord(int bits, EBitCoordType coordType) { - bool bIntegral = (coordType == kCW_Integral); - bool bLowPrecision = (coordType == kCW_LowPrecision); - - int intval = 0, fractval = 0; - float value = 0.0; - - if (bIntegral) - value = ReadUBitLong(bits); - else { - intval = ReadUBitLong(bits); - - // If there's a fraction, read it in - fractval = ReadUBitLong(bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS); - - // Calculate the correct floating point value - value = intval + ((float)fractval * (bLowPrecision ? COORD_RESOLUTION_LOWPRECISION : COORD_RESOLUTION)); - } - - return value; - } - - INLINE float ReadBitNormal() { - // Read the sign bit - i32 signbit = ReadOneBit(); - - // Read the fractional part - u32 fractval = ReadUBitLong(NORMAL_FRACTIONAL_BITS); - - // Calculate the correct floating point value - float value = (float)fractval * NORMAL_RESOLUTION; - - // Fixup the sign if negative. - if (signbit) - value = -value; - - return value; - } - - INLINE void ReadBitVec3Coord(Vector& fa) { - i32 xflag, yflag, zflag; - - // This vector must be initialized! Otherwise, If any of the flags aren't set, - // the corresponding component will not be read and will be stack garbage. - fa.Init(0, 0, 0); - - xflag = ReadOneBit(); - yflag = ReadOneBit(); - zflag = ReadOneBit(); - - if (xflag) - fa[0] = ReadBitCoord(); - if (yflag) - fa[1] = ReadBitCoord(); - if (zflag) - fa[2] = ReadBitCoord(); - } - - INLINE void ReadBitVec3Normal(Vector& fa) { - i32 xflag = ReadOneBit(); - i32 yflag = ReadOneBit(); - - if (xflag) - fa[0] = ReadBitNormal(); - else - fa[0] = 0.0f; - - if (yflag) - fa[1] = ReadBitNormal(); - else - fa[1] = 0.0f; - - // The first two imply the third (but not its sign) - i32 znegative = ReadOneBit(); - - float fafafbfb = fa[0] * fa[0] + fa[1] * fa[1]; - if (fafafbfb < 1.0f) - fa[2] = sqrt(1.0f - fafafbfb); - else - fa[2] = 0.0f; - - if (znegative) - fa[2] = -fa[2]; - } - - INLINE void ReadBitAngles(QAngle& fa) { - Vector tmp; - ReadBitVec3Coord(tmp); - fa.Init(tmp.x, tmp.y, tmp.z); - }*/ - - INLINE float ReadBitAngle(int numBits) { - float shift = (float)(GetBitForBitnum(numBits)); - - i32 i = ReadUBitLong(numBits); - float fReturn = (float)i * (360.0 / shift); - - return fReturn; - } - - INLINE i32 ReadChar() { return ReadSBitLong(sizeof(char) << 3); } - INLINE u32 ReadByte() { return ReadUBitLong(sizeof(unsigned char) << 3); } - - INLINE i32 ReadShort() { return ReadSBitLong(sizeof(short) << 3); } - INLINE u32 ReadWord() { return ReadUBitLong(sizeof(unsigned short) << 3); } - - INLINE i32 ReadLong() { return (i32)(ReadUBitLong(sizeof(i32) << 3)); } - INLINE float ReadFloat() { - u32 temp = ReadUBitLong(sizeof(float) << 3); - return *reinterpret_cast(&temp); - } - - INLINE u32 ReadVarInt32() { - constexpr int kMaxVarint32Bytes = 5; - - u32 result = 0; - int count = 0; - u32 b; - - do { - if (count == kMaxVarint32Bytes) - return result; - - b = ReadUBitLong(8); - result |= (b & 0x7F) << (7 * count); - ++count; - } while (b & 0x80); - - return result; - } - - INLINE u64 ReadVarInt64() { - constexpr int kMaxVarintBytes = 10; - - u64 result = 0; - int count = 0; - u64 b; - - do { - if (count == kMaxVarintBytes) - return result; - - b = ReadUBitLong(8); - result |= static_cast(b & 0x7F) << (7 * count); - ++count; - } while (b & 0x80); - - return result; - } - - INLINE void ReadBits(uptr outData, u32 bitLength) { - u8* out = reinterpret_cast(outData); - int bitsLeft = bitLength; - - // align output to dword boundary - while (((uptr)out & 3) != 0 && bitsLeft >= 8) { - *out = (unsigned char)ReadUBitLong(8); - ++out; - bitsLeft -= 8; - } - - // read dwords - while (bitsLeft >= 32) { - *((u32*)out) = ReadUBitLong(32); - out += sizeof(u32); - bitsLeft -= 32; - } - - // read remaining bytes - while (bitsLeft >= 8) { - *out = ReadUBitLong(8); - ++out; - bitsLeft -= 8; - } - - // read remaining bits - if (bitsLeft) - *out = ReadUBitLong(bitsLeft); - } - - INLINE bool ReadBytes(uptr outData, u32 byteLength) { - ReadBits(outData, byteLength << 3); - return !IsOverflowed(); - } - - INLINE bool ReadString(char* str, i32 maxLength, bool stopAtLineTermination = false, i32* outNumChars = 0) { - bool tooSmall = false; - int iChar = 0; - - while (1) { - char val = ReadChar(); - - if (val == 0) - break; - else if (stopAtLineTermination && val == '\n') - break; - - if (iChar < (maxLength - 1)) { - str[iChar] = val; - ++iChar; - } - else { - tooSmall = true; - } - } - - // Make sure it's null-terminated. - // Assert(iChar < maxLength); - str[iChar] = 0; - - if (outNumChars) - *outNumChars = iChar; - - return !IsOverflowed() && !tooSmall; - } - - INLINE char* ReadAndAllocateString(bool* hasOverflowed = 0) { - char str[2048]; - - int chars = 0; - bool overflowed = !ReadString(str, sizeof(str), false, &chars); - - if (hasOverflowed) - *hasOverflowed = overflowed; - - // Now copy into the output and return it; - char* ret = new char[chars + 1]; - for (u32 i = 0; i <= chars; i++) - ret[i] = str[i]; - - return ret; - } - - INLINE i64 ReadLongLong() { - i64 retval; - u32* longs = (u32*)&retval; - - // Read the two DWORDs according to network endian - const short endianIndex = 0x0100; - u8* idx = (u8*)&endianIndex; - - longs[*idx++] = ReadUBitLong(sizeof(i32) << 3); - longs[*idx] = ReadUBitLong(sizeof(i32) << 3); - - return retval; - } - - INLINE bool Seek(size_t startPos) { - bool bSucc = true; - - if (startPos < 0 || startPos > m_DataBits) { - SetOverflowed(); - bSucc = false; - startPos = m_DataBits; - } - - // non-multiple-of-4 bytes at head of buffer. We put the "round off" - // at the head to make reading and detecting the end efficient. - int nHead = m_DataBytes & 3; - - int posBytes = startPos / 8; - if ((m_DataBytes < 4) || (nHead && (posBytes < nHead))) { - // partial first dword - u8 const* partial = (u8 const*)m_Data; - - if (m_Data) { - m_CachedBufWord = *(partial++); - if (nHead > 1) - m_CachedBufWord |= (*partial++) << 8; - if (nHead > 2) - m_CachedBufWord |= (*partial++) << 16; - } - - m_DataIn = (u32 const*)partial; - - m_CachedBufWord >>= (startPos & 31); - m_CachedBitsLeft = (nHead << 3) - (startPos & 31); - } - else { - int adjustedPos = startPos - (nHead << 3); - - m_DataIn = reinterpret_cast( - reinterpret_cast(m_Data) + ((adjustedPos / 32) << 2) + nHead); - - if (m_Data) { - m_CachedBitsLeft = 32; - GrabNextDWord(); - } - else { - m_CachedBufWord = 0; - m_CachedBitsLeft = 1; - } - - m_CachedBufWord >>= (adjustedPos & 31); - m_CachedBitsLeft = std::min(m_CachedBitsLeft, u32(32 - (adjustedPos & 31))); // in case grabnextdword overflowed - } - - return bSucc; - } - - INLINE size_t GetNumBitsRead() { - if (!m_Data) - return 0; - - size_t nCurOfs = size_t(((iptr(m_DataIn) - iptr(m_Data)) / 4) - 1); - nCurOfs *= 32; - nCurOfs += (32 - m_CachedBitsLeft); - - size_t nAdjust = 8 * (m_DataBytes & 3); - return std::min(nCurOfs + nAdjust, m_DataBits); - } - - INLINE bool SeekRelative(size_t offset) { - return Seek(GetNumBitsRead() + offset); - } - - INLINE size_t TotalBytesAvailable() { return m_DataBytes; } - - INLINE size_t GetNumBitsLeft() { return m_DataBits - GetNumBitsRead(); } - INLINE size_t GetNumBytesLeft() { return GetNumBitsLeft() >> 3; } - -private: - size_t m_DataBits; //0x0010 - size_t m_DataBytes; //0x0018 - - u32 m_CachedBufWord; //0x0020 - u32 m_CachedBitsLeft; //0x0024 - - const u32* m_DataIn; //0x0028 - const u32* m_DataEnd; //0x0030 - const u32* m_Data; //0x0038 +class BFRead : public BitBufferBase +{ + public: + BFRead() = default; + + INLINE BFRead(uptr data, size_t byteLength, size_t startPos = 0, const char* bufferName = 0) + { + StartReading(data, byteLength, startPos); + + if (bufferName) + SetName(bufferName); + } + + public: + INLINE void StartReading(uptr data, size_t byteLength, size_t startPos = 0) + { + m_Data = reinterpret_cast(data); + m_DataIn = m_Data; + + m_DataBytes = byteLength; + m_DataBits = byteLength << 3; + + m_DataEnd = reinterpret_cast(reinterpret_cast(m_Data) + m_DataBytes); + + Seek(startPos); + } + + INLINE void GrabNextDWord(bool overflow = false) + { + if (m_Data == m_DataEnd) + { + m_CachedBitsLeft = 1; + m_CachedBufWord = 0; + + m_DataIn++; + + if (overflow) + SetOverflowed(); + } + else + { + if (m_DataIn > m_DataEnd) + { + SetOverflowed(); + m_CachedBufWord = 0; + } + else + { + m_CachedBufWord = LittleDWord(*(m_DataIn++)); + } + } + } + + INLINE void FetchNext() + { + m_CachedBitsLeft = 32; + GrabNextDWord(false); + } + + INLINE i32 ReadOneBit() + { + i32 ret = m_CachedBufWord & 1; + + if (--m_CachedBitsLeft == 0) + FetchNext(); + else + m_CachedBufWord >>= 1; + + return ret; + } + + INLINE u32 ReadUBitLong(i32 numBits) + { + if (m_CachedBitsLeft >= numBits) + { + u32 ret = m_CachedBufWord & s_nMaskTable[numBits]; + + m_CachedBitsLeft -= numBits; + + if (m_CachedBitsLeft) + m_CachedBufWord >>= numBits; + else + FetchNext(); + + return ret; + } + else + { + // need to merge words + u32 ret = m_CachedBufWord; + numBits -= m_CachedBitsLeft; + + GrabNextDWord(true); + + if (IsOverflowed()) + return 0; + + ret |= ((m_CachedBufWord & s_nMaskTable[numBits]) << m_CachedBitsLeft); + + m_CachedBitsLeft = 32 - numBits; + m_CachedBufWord >>= numBits; + + return ret; + } + } + + INLINE i32 ReadSBitLong(int numBits) + { + i32 ret = ReadUBitLong(numBits); + return (ret << (32 - numBits)) >> (32 - numBits); + } + + INLINE u32 ReadUBitVar() + { + u32 ret = ReadUBitLong(6); + + switch (ret & (16 | 32)) + { + case 16: + ret = (ret & 15) | (ReadUBitLong(4) << 4); + // Assert(ret >= 16); + break; + case 32: + ret = (ret & 15) | (ReadUBitLong(8) << 4); + // Assert(ret >= 256); + break; + case 48: + ret = (ret & 15) | (ReadUBitLong(32 - 4) << 4); + // Assert(ret >= 4096); + break; + } + + return ret; + } + + INLINE u32 PeekUBitLong(i32 numBits) + { + i32 nSaveBA = m_CachedBitsLeft; + i32 nSaveW = m_CachedBufWord; + u32 const* pSaveP = m_DataIn; + u32 nRet = ReadUBitLong(numBits); + + m_CachedBitsLeft = nSaveBA; + m_CachedBufWord = nSaveW; + m_DataIn = pSaveP; + + return nRet; + } + + INLINE float ReadBitFloat() + { + u32 value = ReadUBitLong(32); + return *reinterpret_cast(&value); + } + + /*INLINE float ReadBitCoord() { + i32 intval = 0, fractval = 0, signbit = 0; + float value = 0.0; + + // Read the required integer and fraction flags + intval = ReadOneBit(); + fractval = ReadOneBit(); + + // If we got either parse them, otherwise it's a zero. + if (intval || fractval) { + // Read the sign bit + signbit = ReadOneBit(); + + // If there's an integer, read it in + if (intval) { + // Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE] + intval = ReadUBitLong(COORD_INTEGER_BITS) + 1; + } + + // If there's a fraction, read it in + if (fractval) { + fractval = ReadUBitLong(COORD_FRACTIONAL_BITS); + } + + // Calculate the correct floating point value + value = intval + ((float)fractval * COORD_RESOLUTION); + + // Fixup the sign if negative. + if (signbit) + value = -value; + } + + return value; + } + + INLINE float ReadBitCoordMP() { + i32 intval = 0, fractval = 0, signbit = 0; + float value = 0.0; + + bool inBounds = ReadOneBit() ? true : false; + + // Read the required integer and fraction flags + intval = ReadOneBit(); + + // If we got either parse them, otherwise it's a zero. + if (intval) { + // Read the sign bit + signbit = ReadOneBit(); + + // If there's an integer, read it in + // Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE] + if (inBounds) + value = ReadUBitLong(COORD_INTEGER_BITS_MP) + 1; + else + value = ReadUBitLong(COORD_INTEGER_BITS) + 1; + } + + // Fixup the sign if negative. + if (signbit) + value = -value; + + return value; + } + + INLINE float ReadBitCellCoord(int bits, EBitCoordType coordType) { + bool bIntegral = (coordType == kCW_Integral); + bool bLowPrecision = (coordType == kCW_LowPrecision); + + int intval = 0, fractval = 0; + float value = 0.0; + + if (bIntegral) + value = ReadUBitLong(bits); + else { + intval = ReadUBitLong(bits); + + // If there's a fraction, read it in + fractval = ReadUBitLong(bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS); + + // Calculate the correct floating point value + value = intval + ((float)fractval * (bLowPrecision ? COORD_RESOLUTION_LOWPRECISION : COORD_RESOLUTION)); + } + + return value; + } + + INLINE float ReadBitNormal() { + // Read the sign bit + i32 signbit = ReadOneBit(); + + // Read the fractional part + u32 fractval = ReadUBitLong(NORMAL_FRACTIONAL_BITS); + + // Calculate the correct floating point value + float value = (float)fractval * NORMAL_RESOLUTION; + + // Fixup the sign if negative. + if (signbit) + value = -value; + + return value; + } + + INLINE void ReadBitVec3Coord(Vector& fa) { + i32 xflag, yflag, zflag; + + // This vector must be initialized! Otherwise, If any of the flags aren't set, + // the corresponding component will not be read and will be stack garbage. + fa.Init(0, 0, 0); + + xflag = ReadOneBit(); + yflag = ReadOneBit(); + zflag = ReadOneBit(); + + if (xflag) + fa[0] = ReadBitCoord(); + if (yflag) + fa[1] = ReadBitCoord(); + if (zflag) + fa[2] = ReadBitCoord(); + } + + INLINE void ReadBitVec3Normal(Vector& fa) { + i32 xflag = ReadOneBit(); + i32 yflag = ReadOneBit(); + + if (xflag) + fa[0] = ReadBitNormal(); + else + fa[0] = 0.0f; + + if (yflag) + fa[1] = ReadBitNormal(); + else + fa[1] = 0.0f; + + // The first two imply the third (but not its sign) + i32 znegative = ReadOneBit(); + + float fafafbfb = fa[0] * fa[0] + fa[1] * fa[1]; + if (fafafbfb < 1.0f) + fa[2] = sqrt(1.0f - fafafbfb); + else + fa[2] = 0.0f; + + if (znegative) + fa[2] = -fa[2]; + } + + INLINE void ReadBitAngles(QAngle& fa) { + Vector tmp; + ReadBitVec3Coord(tmp); + fa.Init(tmp.x, tmp.y, tmp.z); + }*/ + + INLINE float ReadBitAngle(int numBits) + { + float shift = (float)(GetBitForBitnum(numBits)); + + i32 i = ReadUBitLong(numBits); + float fReturn = (float)i * (360.0 / shift); + + return fReturn; + } + + INLINE i32 ReadChar() { return ReadSBitLong(sizeof(char) << 3); } + INLINE u32 ReadByte() { return ReadUBitLong(sizeof(unsigned char) << 3); } + + INLINE i32 ReadShort() { return ReadSBitLong(sizeof(short) << 3); } + INLINE u32 ReadWord() { return ReadUBitLong(sizeof(unsigned short) << 3); } + + INLINE i32 ReadLong() { return (i32)(ReadUBitLong(sizeof(i32) << 3)); } + INLINE float ReadFloat() + { + u32 temp = ReadUBitLong(sizeof(float) << 3); + return *reinterpret_cast(&temp); + } + + INLINE u32 ReadVarInt32() + { + constexpr int kMaxVarint32Bytes = 5; + + u32 result = 0; + int count = 0; + u32 b; + + do + { + if (count == kMaxVarint32Bytes) + return result; + + b = ReadUBitLong(8); + result |= (b & 0x7F) << (7 * count); + ++count; + } while (b & 0x80); + + return result; + } + + INLINE u64 ReadVarInt64() + { + constexpr int kMaxVarintBytes = 10; + + u64 result = 0; + int count = 0; + u64 b; + + do + { + if (count == kMaxVarintBytes) + return result; + + b = ReadUBitLong(8); + result |= static_cast(b & 0x7F) << (7 * count); + ++count; + } while (b & 0x80); + + return result; + } + + INLINE void ReadBits(uptr outData, u32 bitLength) + { + u8* out = reinterpret_cast(outData); + int bitsLeft = bitLength; + + // align output to dword boundary + while (((uptr)out & 3) != 0 && bitsLeft >= 8) + { + *out = (unsigned char)ReadUBitLong(8); + ++out; + bitsLeft -= 8; + } + + // read dwords + while (bitsLeft >= 32) + { + *((u32*)out) = ReadUBitLong(32); + out += sizeof(u32); + bitsLeft -= 32; + } + + // read remaining bytes + while (bitsLeft >= 8) + { + *out = ReadUBitLong(8); + ++out; + bitsLeft -= 8; + } + + // read remaining bits + if (bitsLeft) + *out = ReadUBitLong(bitsLeft); + } + + INLINE bool ReadBytes(uptr outData, u32 byteLength) + { + ReadBits(outData, byteLength << 3); + return !IsOverflowed(); + } + + INLINE bool ReadString(char* str, i32 maxLength, bool stopAtLineTermination = false, i32* outNumChars = 0) + { + bool tooSmall = false; + int iChar = 0; + + while (1) + { + char val = ReadChar(); + + if (val == 0) + break; + else if (stopAtLineTermination && val == '\n') + break; + + if (iChar < (maxLength - 1)) + { + str[iChar] = val; + ++iChar; + } + else + { + tooSmall = true; + } + } + + // Make sure it's null-terminated. + // Assert(iChar < maxLength); + str[iChar] = 0; + + if (outNumChars) + *outNumChars = iChar; + + return !IsOverflowed() && !tooSmall; + } + + INLINE char* ReadAndAllocateString(bool* hasOverflowed = 0) + { + char str[2048]; + + int chars = 0; + bool overflowed = !ReadString(str, sizeof(str), false, &chars); + + if (hasOverflowed) + *hasOverflowed = overflowed; + + // Now copy into the output and return it; + char* ret = new char[chars + 1]; + for (u32 i = 0; i <= chars; i++) + ret[i] = str[i]; + + return ret; + } + + INLINE i64 ReadLongLong() + { + i64 retval; + u32* longs = (u32*)&retval; + + // Read the two DWORDs according to network endian + const short endianIndex = 0x0100; + u8* idx = (u8*)&endianIndex; + + longs[*idx++] = ReadUBitLong(sizeof(i32) << 3); + longs[*idx] = ReadUBitLong(sizeof(i32) << 3); + + return retval; + } + + INLINE bool Seek(size_t startPos) + { + bool bSucc = true; + + if (startPos < 0 || startPos > m_DataBits) + { + SetOverflowed(); + bSucc = false; + startPos = m_DataBits; + } + + // non-multiple-of-4 bytes at head of buffer. We put the "round off" + // at the head to make reading and detecting the end efficient. + int nHead = m_DataBytes & 3; + + int posBytes = startPos / 8; + if ((m_DataBytes < 4) || (nHead && (posBytes < nHead))) + { + // partial first dword + u8 const* partial = (u8 const*)m_Data; + + if (m_Data) + { + m_CachedBufWord = *(partial++); + if (nHead > 1) + m_CachedBufWord |= (*partial++) << 8; + if (nHead > 2) + m_CachedBufWord |= (*partial++) << 16; + } + + m_DataIn = (u32 const*)partial; + + m_CachedBufWord >>= (startPos & 31); + m_CachedBitsLeft = (nHead << 3) - (startPos & 31); + } + else + { + int adjustedPos = startPos - (nHead << 3); + + m_DataIn = reinterpret_cast(reinterpret_cast(m_Data) + ((adjustedPos / 32) << 2) + nHead); + + if (m_Data) + { + m_CachedBitsLeft = 32; + GrabNextDWord(); + } + else + { + m_CachedBufWord = 0; + m_CachedBitsLeft = 1; + } + + m_CachedBufWord >>= (adjustedPos & 31); + m_CachedBitsLeft = std::min(m_CachedBitsLeft, u32(32 - (adjustedPos & 31))); // in case grabnextdword overflowed + } + + return bSucc; + } + + INLINE size_t GetNumBitsRead() + { + if (!m_Data) + return 0; + + size_t nCurOfs = size_t(((iptr(m_DataIn) - iptr(m_Data)) / 4) - 1); + nCurOfs *= 32; + nCurOfs += (32 - m_CachedBitsLeft); + + size_t nAdjust = 8 * (m_DataBytes & 3); + return std::min(nCurOfs + nAdjust, m_DataBits); + } + + INLINE bool SeekRelative(size_t offset) { return Seek(GetNumBitsRead() + offset); } + + INLINE size_t TotalBytesAvailable() { return m_DataBytes; } + + INLINE size_t GetNumBitsLeft() { return m_DataBits - GetNumBitsRead(); } + INLINE size_t GetNumBytesLeft() { return GetNumBitsLeft() >> 3; } + + private: + size_t m_DataBits; // 0x0010 + size_t m_DataBytes; // 0x0018 + + u32 m_CachedBufWord; // 0x0020 + u32 m_CachedBitsLeft; // 0x0024 + + const u32* m_DataIn; // 0x0028 + const u32* m_DataEnd; // 0x0030 + const u32* m_Data; // 0x0038 }; -class BFWrite : public BitBufferBase { -public: - BFWrite() = default; - - INLINE BFWrite(uptr data, size_t byteLength, const char* bufferName = 0) { - StartWriting(data, byteLength); - - if (bufferName) - SetName(bufferName); - } - -public: - INLINE void StartWriting(uptr data, size_t byteLength) { - m_Data = reinterpret_cast(data); - m_DataOut = m_Data; - - m_DataBytes = byteLength; - m_DataBits = byteLength << 3; - - m_DataEnd = reinterpret_cast(reinterpret_cast(m_Data) + m_DataBytes); - } - - INLINE int GetNumBitsLeft() { - return m_OutBitsLeft + (32 * (m_DataEnd - m_DataOut - 1)); - } - - INLINE void Reset() { - m_Overflow = false; - m_OutBufWord = 0; - m_OutBitsLeft = 32; - m_DataOut = m_Data; - } - - INLINE void TempFlush() { - if (m_OutBitsLeft != 32) { - if (m_DataOut == m_DataEnd) - SetOverflowed(); - else - StoreLittleDWord(m_DataOut, 0, LoadLittleDWord(m_DataOut, 0) & ~s_nMaskTable[32 - m_OutBitsLeft] | m_OutBufWord); - } - - m_Flushed = true; - } - - INLINE u8* GetBasePointer() { - TempFlush(); - return reinterpret_cast(m_Data); - } - - INLINE u8* GetData() { - return GetBasePointer(); - } - - INLINE void Finish() { - if (m_OutBitsLeft != 32) { - if (m_DataOut == m_DataEnd) - SetOverflowed(); - - StoreLittleDWord(m_DataOut, 0, m_OutBufWord); - } - } - - INLINE void FlushNoCheck() { - StoreLittleDWord(m_DataOut++, 0, m_OutBufWord); - - m_OutBitsLeft = 32; - m_OutBufWord = 0; - } - - INLINE void Flush() { - if (m_DataOut == m_DataEnd) - SetOverflowed(); - else - StoreLittleDWord(m_DataOut++, 0, m_OutBufWord); - - m_OutBitsLeft = 32; - m_OutBufWord = 0; - } - - INLINE void WriteOneBitNoCheck(i32 value) { - m_OutBufWord |= (value & 1) << (32 - m_OutBitsLeft); - - if (--m_OutBitsLeft == 0) - FlushNoCheck(); - } - - INLINE void WriteOneBit(i32 value) { - m_OutBufWord |= (value & 1) << (32 - m_OutBitsLeft); - - if (--m_OutBitsLeft == 0) - Flush(); - } - - INLINE void WriteUBitLong(u32 data, i32 numBits, bool checkRange = true) { - if (numBits <= m_OutBitsLeft) { - if (checkRange) - m_OutBufWord |= (data) << (32 - m_OutBitsLeft); - else - m_OutBufWord |= (data & s_nMaskTable[numBits]) << (32 - m_OutBitsLeft); - - m_OutBitsLeft -= numBits; - - if (m_OutBitsLeft == 0) - Flush(); - } - else { - // split dwords case - i32 overflowBits = (numBits - m_OutBitsLeft); - m_OutBufWord |= (data & s_nMaskTable[m_OutBitsLeft]) << (32 - m_OutBitsLeft); - Flush(); - m_OutBufWord = (data >> (numBits - overflowBits)); - m_OutBitsLeft = 32 - overflowBits; - } - } - - INLINE void WriteSBitLong(i32 data, i32 numBits) { - WriteUBitLong((u32)data, numBits, false); - } - - INLINE void WriteUBitVar(u32 n) { - if (n < 16) - WriteUBitLong(n, 6); - else if (n < 256) - WriteUBitLong((n & 15) | 16 | ((n & (128 | 64 | 32 | 16)) << 2), 10); - else if (n < 4096) - WriteUBitLong((n & 15) | 32 | ((n & (2048 | 1024 | 512 | 256 | 128 | 64 | 32 | 16)) << 2), 14); - else { - WriteUBitLong((n & 15) | 48, 6); - WriteUBitLong((n >> 4), 32 - 4); - } - } - - INLINE void WriteBitFloat(float value) { - auto temp = &value; - WriteUBitLong(*reinterpret_cast(temp), 32); - } - - INLINE void WriteFloat(float value) { - auto temp = &value; - WriteUBitLong(*reinterpret_cast(temp), 32); - } - - INLINE bool WriteBits(const uptr data, i32 numBits) { - u8* out = (u8*)data; - i32 numBitsLeft = numBits; - - // Bounds checking.. - if ((GetNumBitsWritten() + numBits) > m_DataBits) { - SetOverflowed(); - return false; - } - - // !! speed!! need fast paths - // write remaining bytes - while (numBitsLeft >= 8) { - WriteUBitLong(*out, 8, false); - ++out; - numBitsLeft -= 8; - } - - // write remaining bits - if (numBitsLeft) - WriteUBitLong(*out, numBitsLeft, false); - - return !IsOverflowed(); - } - - INLINE bool WriteBytes(const uptr data, i32 numBytes) { - return WriteBits(data, numBytes << 3); - } - - INLINE i32 GetNumBitsWritten() { - return (32 - m_OutBitsLeft) + (32 * (m_DataOut - m_Data)); - } - - INLINE i32 GetNumBytesWritten() { - return (GetNumBitsWritten() + 7) >> 3; - } - - INLINE void WriteChar(i32 val) { - WriteSBitLong(val, sizeof(char) << 3); - } - - INLINE void WriteByte(i32 val) { - WriteUBitLong(val, sizeof(unsigned char) << 3, false); - } - - INLINE void WriteShort(i32 val) { - WriteSBitLong(val, sizeof(short) << 3); - } - - INLINE void WriteWord(i32 val) { - WriteUBitLong(val, sizeof(unsigned short) << 3); - } - - INLINE bool WriteString(const char* str) { - if (str) - while (*str) - WriteChar(*(str++)); - - WriteChar(0); - - return !IsOverflowed(); - } - - INLINE void WriteLongLong(i64 val) { - u32* pLongs = (u32*)&val; - - // Insert the two DWORDS according to network endian - const short endianIndex = 0x0100; - u8* idx = (u8*)&endianIndex; - - WriteUBitLong(pLongs[*idx++], sizeof(i32) << 3); - WriteUBitLong(pLongs[*idx], sizeof(i32) << 3); - } - - /*INLINE void WriteBitCoord(const float f) { - i32 signbit = (f <= -COORD_RESOLUTION); - i32 intval = (i32)abs(f); - i32 fractval = abs((i32)(f * COORD_DENOMINATOR)) & (COORD_DENOMINATOR - 1); - - // Send the bit flags that indicate whether we have an integer part and/or a fraction part. - WriteOneBit(intval); - WriteOneBit(fractval); - - if (intval || fractval) { - // Send the sign bit - WriteOneBit(signbit); - - // Send the integer if we have one. - if (intval) { - // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] - intval--; - WriteUBitLong((u32)intval, COORD_INTEGER_BITS); - } - - // Send the fraction if we have one - if (fractval) { - WriteUBitLong((u32)fractval, COORD_FRACTIONAL_BITS); - } - } - } - - INLINE void WriteBitCoordMP(const float f) { - i32 signbit = (f <= -COORD_RESOLUTION); - i32 intval = (i32)abs(f); - i32 fractval = (abs((i32)(f * COORD_DENOMINATOR)) & (COORD_DENOMINATOR - 1)); - - bool bInBounds = intval < (1 << COORD_INTEGER_BITS_MP); - - WriteOneBit(bInBounds); - - // Send the sign bit - WriteOneBit(intval); - - if (intval) { - WriteOneBit(signbit); - - // Send the integer if we have one. - // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] - intval--; - - if (bInBounds) - WriteUBitLong((u32)intval, COORD_INTEGER_BITS_MP); - else - WriteUBitLong((u32)intval, COORD_INTEGER_BITS); - } - } - - INLINE void WriteBitCellCoord(const float f, int bits, EBitCoordType coordType) { - bool bIntegral = (coordType == kCW_Integral); - bool bLowPrecision = (coordType == kCW_LowPrecision); - - i32 intval = (i32)abs(f); - i32 fractval = bLowPrecision ? (abs((i32)(f * COORD_DENOMINATOR_LOWPRECISION)) & (COORD_DENOMINATOR_LOWPRECISION - 1)) : (abs((i32)(f * COORD_DENOMINATOR)) & (COORD_DENOMINATOR - 1)); - - if (bIntegral) - WriteUBitLong((u32)intval, bits); - else { - WriteUBitLong((u32)intval, bits); - WriteUBitLong((u32)fractval, bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS); - } - }*/ - - INLINE void SeekToBit(int bit) { - TempFlush(); +class BFWrite : public BitBufferBase +{ + public: + BFWrite() = default; + + INLINE BFWrite(uptr data, size_t byteLength, const char* bufferName = 0) + { + StartWriting(data, byteLength); + + if (bufferName) + SetName(bufferName); + } + + public: + INLINE void StartWriting(uptr data, size_t byteLength) + { + m_Data = reinterpret_cast(data); + m_DataOut = m_Data; + + m_DataBytes = byteLength; + m_DataBits = byteLength << 3; + + m_DataEnd = reinterpret_cast(reinterpret_cast(m_Data) + m_DataBytes); + } + + INLINE int GetNumBitsLeft() { return m_OutBitsLeft + (32 * (m_DataEnd - m_DataOut - 1)); } + + INLINE void Reset() + { + m_Overflow = false; + m_OutBufWord = 0; + m_OutBitsLeft = 32; + m_DataOut = m_Data; + } + + INLINE void TempFlush() + { + if (m_OutBitsLeft != 32) + { + if (m_DataOut == m_DataEnd) + SetOverflowed(); + else + StoreLittleDWord(m_DataOut, 0, LoadLittleDWord(m_DataOut, 0) & ~s_nMaskTable[32 - m_OutBitsLeft] | m_OutBufWord); + } + + m_Flushed = true; + } + + INLINE u8* GetBasePointer() + { + TempFlush(); + return reinterpret_cast(m_Data); + } + + INLINE u8* GetData() { return GetBasePointer(); } + + INLINE void Finish() + { + if (m_OutBitsLeft != 32) + { + if (m_DataOut == m_DataEnd) + SetOverflowed(); + + StoreLittleDWord(m_DataOut, 0, m_OutBufWord); + } + } + + INLINE void FlushNoCheck() + { + StoreLittleDWord(m_DataOut++, 0, m_OutBufWord); + + m_OutBitsLeft = 32; + m_OutBufWord = 0; + } + + INLINE void Flush() + { + if (m_DataOut == m_DataEnd) + SetOverflowed(); + else + StoreLittleDWord(m_DataOut++, 0, m_OutBufWord); + + m_OutBitsLeft = 32; + m_OutBufWord = 0; + } + + INLINE void WriteOneBitNoCheck(i32 value) + { + m_OutBufWord |= (value & 1) << (32 - m_OutBitsLeft); + + if (--m_OutBitsLeft == 0) + FlushNoCheck(); + } + + INLINE void WriteOneBit(i32 value) + { + m_OutBufWord |= (value & 1) << (32 - m_OutBitsLeft); + + if (--m_OutBitsLeft == 0) + Flush(); + } + + INLINE void WriteUBitLong(u32 data, i32 numBits, bool checkRange = true) + { + if (numBits <= m_OutBitsLeft) + { + if (checkRange) + m_OutBufWord |= (data) << (32 - m_OutBitsLeft); + else + m_OutBufWord |= (data & s_nMaskTable[numBits]) << (32 - m_OutBitsLeft); + + m_OutBitsLeft -= numBits; + + if (m_OutBitsLeft == 0) + Flush(); + } + else + { + // split dwords case + i32 overflowBits = (numBits - m_OutBitsLeft); + m_OutBufWord |= (data & s_nMaskTable[m_OutBitsLeft]) << (32 - m_OutBitsLeft); + Flush(); + m_OutBufWord = (data >> (numBits - overflowBits)); + m_OutBitsLeft = 32 - overflowBits; + } + } + + INLINE void WriteSBitLong(i32 data, i32 numBits) { WriteUBitLong((u32)data, numBits, false); } + + INLINE void WriteUBitVar(u32 n) + { + if (n < 16) + WriteUBitLong(n, 6); + else if (n < 256) + WriteUBitLong((n & 15) | 16 | ((n & (128 | 64 | 32 | 16)) << 2), 10); + else if (n < 4096) + WriteUBitLong((n & 15) | 32 | ((n & (2048 | 1024 | 512 | 256 | 128 | 64 | 32 | 16)) << 2), 14); + else + { + WriteUBitLong((n & 15) | 48, 6); + WriteUBitLong((n >> 4), 32 - 4); + } + } + + INLINE void WriteBitFloat(float value) + { + auto temp = &value; + WriteUBitLong(*reinterpret_cast(temp), 32); + } + + INLINE void WriteFloat(float value) + { + auto temp = &value; + WriteUBitLong(*reinterpret_cast(temp), 32); + } + + INLINE bool WriteBits(const uptr data, i32 numBits) + { + u8* out = (u8*)data; + i32 numBitsLeft = numBits; + + // Bounds checking.. + if ((GetNumBitsWritten() + numBits) > m_DataBits) + { + SetOverflowed(); + return false; + } + + // !! speed!! need fast paths + // write remaining bytes + while (numBitsLeft >= 8) + { + WriteUBitLong(*out, 8, false); + ++out; + numBitsLeft -= 8; + } + + // write remaining bits + if (numBitsLeft) + WriteUBitLong(*out, numBitsLeft, false); + + return !IsOverflowed(); + } + + INLINE bool WriteBytes(const uptr data, i32 numBytes) { return WriteBits(data, numBytes << 3); } + + INLINE i32 GetNumBitsWritten() { return (32 - m_OutBitsLeft) + (32 * (m_DataOut - m_Data)); } + + INLINE i32 GetNumBytesWritten() { return (GetNumBitsWritten() + 7) >> 3; } + + INLINE void WriteChar(i32 val) { WriteSBitLong(val, sizeof(char) << 3); } + + INLINE void WriteByte(i32 val) { WriteUBitLong(val, sizeof(unsigned char) << 3, false); } + + INLINE void WriteShort(i32 val) { WriteSBitLong(val, sizeof(short) << 3); } + + INLINE void WriteWord(i32 val) { WriteUBitLong(val, sizeof(unsigned short) << 3); } + + INLINE bool WriteString(const char* str) + { + if (str) + while (*str) + WriteChar(*(str++)); + + WriteChar(0); + + return !IsOverflowed(); + } + + INLINE void WriteLongLong(i64 val) + { + u32* pLongs = (u32*)&val; + + // Insert the two DWORDS according to network endian + const short endianIndex = 0x0100; + u8* idx = (u8*)&endianIndex; + + WriteUBitLong(pLongs[*idx++], sizeof(i32) << 3); + WriteUBitLong(pLongs[*idx], sizeof(i32) << 3); + } + + /*INLINE void WriteBitCoord(const float f) { + i32 signbit = (f <= -COORD_RESOLUTION); + i32 intval = (i32)abs(f); + i32 fractval = abs((i32)(f * COORD_DENOMINATOR)) & (COORD_DENOMINATOR - 1); + + // Send the bit flags that indicate whether we have an integer part and/or a fraction part. + WriteOneBit(intval); + WriteOneBit(fractval); + + if (intval || fractval) { + // Send the sign bit + WriteOneBit(signbit); + + // Send the integer if we have one. + if (intval) { + // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] + intval--; + WriteUBitLong((u32)intval, COORD_INTEGER_BITS); + } + + // Send the fraction if we have one + if (fractval) { + WriteUBitLong((u32)fractval, COORD_FRACTIONAL_BITS); + } + } + } + + INLINE void WriteBitCoordMP(const float f) { + i32 signbit = (f <= -COORD_RESOLUTION); + i32 intval = (i32)abs(f); + i32 fractval = (abs((i32)(f * COORD_DENOMINATOR)) & (COORD_DENOMINATOR - 1)); + + bool bInBounds = intval < (1 << COORD_INTEGER_BITS_MP); - m_DataOut = m_Data + (bit / 32); - m_OutBufWord = LoadLittleDWord(m_DataOut, 0); - m_OutBitsLeft = 32 - (bit & 31); - } - - /*INLINE void WriteBitVec3Coord(const Vector& fa) { - i32 xflag, yflag, zflag; + WriteOneBit(bInBounds); + + // Send the sign bit + WriteOneBit(intval); - xflag = (fa[0] >= COORD_RESOLUTION) || (fa[0] <= -COORD_RESOLUTION); - yflag = (fa[1] >= COORD_RESOLUTION) || (fa[1] <= -COORD_RESOLUTION); - zflag = (fa[2] >= COORD_RESOLUTION) || (fa[2] <= -COORD_RESOLUTION); + if (intval) { + WriteOneBit(signbit); - WriteOneBit(xflag); - WriteOneBit(yflag); - WriteOneBit(zflag); - - if (xflag) - WriteBitCoord(fa[0]); - if (yflag) - WriteBitCoord(fa[1]); - if (zflag) - WriteBitCoord(fa[2]); - } - - INLINE void WriteBitNormal(float f) { - i32 signbit = (f <= -NORMAL_RESOLUTION); - - // NOTE: Since +/-1 are valid values for a normal, I'm going to encode that as all ones - u32 fractval = abs((i32)(f * NORMAL_DENOMINATOR)); - - // clamp.. - if (fractval > NORMAL_DENOMINATOR) - fractval = NORMAL_DENOMINATOR; - - // Send the sign bit - WriteOneBit(signbit); - - // Send the fractional component - WriteUBitLong(fractval, NORMAL_FRACTIONAL_BITS); - } - - INLINE void WriteBitVec3Normal(const Vector& fa) { - i32 xflag, yflag; - - xflag = (fa[0] >= NORMAL_RESOLUTION) || (fa[0] <= -NORMAL_RESOLUTION); - yflag = (fa[1] >= NORMAL_RESOLUTION) || (fa[1] <= -NORMAL_RESOLUTION); - - WriteOneBit(xflag); - WriteOneBit(yflag); - - if (xflag) - WriteBitNormal(fa[0]); - if (yflag) - WriteBitNormal(fa[1]); + // Send the integer if we have one. + // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] + intval--; - // Write z sign bit - i32 signbit = (fa[2] <= -NORMAL_RESOLUTION); - WriteOneBit(signbit); - }*/ + if (bInBounds) + WriteUBitLong((u32)intval, COORD_INTEGER_BITS_MP); + else + WriteUBitLong((u32)intval, COORD_INTEGER_BITS); + } + } - INLINE void WriteBitAngle(float angle, int numBits) { - u32 shift = GetBitForBitnum(numBits); - u32 mask = shift - 1; + INLINE void WriteBitCellCoord(const float f, int bits, EBitCoordType coordType) { + bool bIntegral = (coordType == kCW_Integral); + bool bLowPrecision = (coordType == kCW_LowPrecision); - i32 d = (i32)((angle / 360.0) * shift); - d &= mask; - - WriteUBitLong((u32)d, numBits); - } - - INLINE bool WriteBitsFromBuffer(BFRead* in, int numBits) { - while (numBits > 32) { - WriteUBitLong(in->ReadUBitLong(32), 32); - numBits -= 32; - } - - WriteUBitLong(in->ReadUBitLong(numBits), numBits); - return !IsOverflowed() && !in->IsOverflowed(); - } + i32 intval = (i32)abs(f); + i32 fractval = bLowPrecision ? (abs((i32)(f * COORD_DENOMINATOR_LOWPRECISION)) & (COORD_DENOMINATOR_LOWPRECISION - 1)) : + (abs((i32)(f * COORD_DENOMINATOR)) & (COORD_DENOMINATOR - 1)); - /*INLINE void WriteBitAngles(const QAngle& fa) { - // FIXME: - Vector tmp(fa.x, fa.y, fa.z); - WriteBitVec3Coord(tmp); - }*/ + if (bIntegral) + WriteUBitLong((u32)intval, bits); + else { + WriteUBitLong((u32)intval, bits); + WriteUBitLong((u32)fractval, bLowPrecision ? COORD_FRACTIONAL_BITS_MP_LOWPRECISION : COORD_FRACTIONAL_BITS); + } + }*/ -private: - size_t m_DataBits = 0; - size_t m_DataBytes = 0; - - u32 m_OutBufWord = 0; - u32 m_OutBitsLeft = 32; + INLINE void SeekToBit(int bit) + { + TempFlush(); + + m_DataOut = m_Data + (bit / 32); + m_OutBufWord = LoadLittleDWord(m_DataOut, 0); + m_OutBitsLeft = 32 - (bit & 31); + } + + /*INLINE void WriteBitVec3Coord(const Vector& fa) { + i32 xflag, yflag, zflag; + + xflag = (fa[0] >= COORD_RESOLUTION) || (fa[0] <= -COORD_RESOLUTION); + yflag = (fa[1] >= COORD_RESOLUTION) || (fa[1] <= -COORD_RESOLUTION); + zflag = (fa[2] >= COORD_RESOLUTION) || (fa[2] <= -COORD_RESOLUTION); + + WriteOneBit(xflag); + WriteOneBit(yflag); + WriteOneBit(zflag); + + if (xflag) + WriteBitCoord(fa[0]); + if (yflag) + WriteBitCoord(fa[1]); + if (zflag) + WriteBitCoord(fa[2]); + } + + INLINE void WriteBitNormal(float f) { + i32 signbit = (f <= -NORMAL_RESOLUTION); + + // NOTE: Since +/-1 are valid values for a normal, I'm going to encode that as all ones + u32 fractval = abs((i32)(f * NORMAL_DENOMINATOR)); + + // clamp.. + if (fractval > NORMAL_DENOMINATOR) + fractval = NORMAL_DENOMINATOR; + + // Send the sign bit + WriteOneBit(signbit); + + // Send the fractional component + WriteUBitLong(fractval, NORMAL_FRACTIONAL_BITS); + } + + INLINE void WriteBitVec3Normal(const Vector& fa) { + i32 xflag, yflag; + + xflag = (fa[0] >= NORMAL_RESOLUTION) || (fa[0] <= -NORMAL_RESOLUTION); + yflag = (fa[1] >= NORMAL_RESOLUTION) || (fa[1] <= -NORMAL_RESOLUTION); + + WriteOneBit(xflag); + WriteOneBit(yflag); + + if (xflag) + WriteBitNormal(fa[0]); + if (yflag) + WriteBitNormal(fa[1]); + + // Write z sign bit + i32 signbit = (fa[2] <= -NORMAL_RESOLUTION); + WriteOneBit(signbit); + }*/ + + INLINE void WriteBitAngle(float angle, int numBits) + { + u32 shift = GetBitForBitnum(numBits); + u32 mask = shift - 1; + + i32 d = (i32)((angle / 360.0) * shift); + d &= mask; + + WriteUBitLong((u32)d, numBits); + } + + INLINE bool WriteBitsFromBuffer(BFRead* in, int numBits) + { + while (numBits > 32) + { + WriteUBitLong(in->ReadUBitLong(32), 32); + numBits -= 32; + } + + WriteUBitLong(in->ReadUBitLong(numBits), numBits); + return !IsOverflowed() && !in->IsOverflowed(); + } + + /*INLINE void WriteBitAngles(const QAngle& fa) { + // FIXME: + Vector tmp(fa.x, fa.y, fa.z); + WriteBitVec3Coord(tmp); + }*/ + + private: + size_t m_DataBits = 0; + size_t m_DataBytes = 0; + + u32 m_OutBufWord = 0; + u32 m_OutBitsLeft = 32; - u32* m_DataOut = nullptr; - u32* m_DataEnd = nullptr; - u32* m_Data = nullptr; + u32* m_DataOut = nullptr; + u32* m_DataEnd = nullptr; + u32* m_Data = nullptr; - bool m_Flushed = false; // :flushed: + bool m_Flushed = false; // :flushed: }; #undef INLINE \ No newline at end of file -- cgit v1.2.3