#pragma once #define INLINE inline #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)]; } #undef BITS_PER_INT using u8 = uint8_t; using u16 = uint16_t; using u32 = uint32_t; using u64 = uint64_t; using uptr = uintptr_t; using i8 = int8_t; using i16 = int16_t; using i32 = int32_t; using i64 = int64_t; 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 u32 LoadLittleDWord(u32* base, size_t dwordIndex) { return LittleDWord(base[dwordIndex]); } #include <algorithm> 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, }; enum EBitCoordType { kCW_None, kCW_LowPrecision, kCW_Integral }; 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; } INLINE const char* GetName() { return m_BufferName; } private: const char* m_BufferName = ""; 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<u32 const*>(data); m_DataIn = m_Data; m_DataBytes = byteLength; m_DataBits = byteLength << 3; m_DataEnd = reinterpret_cast<u32 const*>(reinterpret_cast<u8 const*>(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<float*>(&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<float*>(&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<u64>(b & 0x7F) << (7 * count); ++count; } while (b & 0x80); return result; } INLINE void ReadBits(uptr outData, u32 bitLength) { u8* out = reinterpret_cast<u8*>(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<u32 const*>(reinterpret_cast<u8 const*>(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<u32*>(data); m_DataOut = m_Data; m_DataBytes = byteLength; m_DataBits = byteLength << 3; m_DataEnd = reinterpret_cast<u32*>(reinterpret_cast<u8*>(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<u8*>(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<u32*>(temp), 32); } INLINE void WriteFloat(float value) { auto temp = &value; WriteUBitLong(*reinterpret_cast<u32*>(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(); 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; bool m_Flushed = false; // :flushed: }; #undef INLINE