mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-11 13:11:47 +00:00
595 lines
12 KiB
C++
595 lines
12 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
#pragma hdrstop
|
|
#include "precompiled.h"
|
|
|
|
/*
|
|
================================================================================================
|
|
|
|
idBitMsg
|
|
|
|
================================================================================================
|
|
*/
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::CheckOverflow
|
|
========================
|
|
*/
|
|
bool idBitMsg::CheckOverflow( int numBits )
|
|
{
|
|
if( numBits > GetRemainingWriteBits() )
|
|
{
|
|
if( !allowOverflow )
|
|
{
|
|
idLib::FatalError( "idBitMsg: overflow without allowOverflow set; maxsize=%i size=%i numBits=%i numRemainingWriteBits=%i",
|
|
GetMaxSize(), GetSize(), numBits, GetRemainingWriteBits() );
|
|
}
|
|
if( numBits > ( maxSize << 3 ) )
|
|
{
|
|
idLib::FatalError( "idBitMsg: %i bits is > full message size", numBits );
|
|
}
|
|
idLib::Printf( "idBitMsg: overflow\n" );
|
|
BeginWriting();
|
|
overflowed = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::GetByteSpace
|
|
========================
|
|
*/
|
|
byte* idBitMsg::GetByteSpace( int length )
|
|
{
|
|
byte* ptr;
|
|
|
|
if( !writeData )
|
|
{
|
|
idLib::FatalError( "idBitMsg::GetByteSpace: cannot write to message" );
|
|
}
|
|
|
|
// round up to the next byte
|
|
WriteByteAlign();
|
|
|
|
// check for overflow
|
|
CheckOverflow( length << 3 );
|
|
|
|
ptr = writeData + curSize;
|
|
curSize += length;
|
|
return ptr;
|
|
}
|
|
|
|
#define NBM( x ) (uint64)( ( 1LL << x ) - 1 )
|
|
static uint64 maskForNumBits64[33] = { NBM( 0x00 ), NBM( 0x01 ), NBM( 0x02 ), NBM( 0x03 ),
|
|
NBM( 0x04 ), NBM( 0x05 ), NBM( 0x06 ), NBM( 0x07 ),
|
|
NBM( 0x08 ), NBM( 0x09 ), NBM( 0x0A ), NBM( 0x0B ),
|
|
NBM( 0x0C ), NBM( 0x0D ), NBM( 0x0E ), NBM( 0x0F ),
|
|
NBM( 0x10 ), NBM( 0x11 ), NBM( 0x12 ), NBM( 0x13 ),
|
|
NBM( 0x14 ), NBM( 0x15 ), NBM( 0x16 ), NBM( 0x17 ),
|
|
NBM( 0x18 ), NBM( 0x19 ), NBM( 0x1A ), NBM( 0x1B ),
|
|
NBM( 0x1C ), NBM( 0x1D ), NBM( 0x1E ), NBM( 0x1F ), 0xFFFFFFFF
|
|
};
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::WriteBits
|
|
|
|
If the number of bits is negative a sign is included.
|
|
========================
|
|
*/
|
|
void idBitMsg::WriteBits( int value, int numBits )
|
|
{
|
|
if( !writeData )
|
|
{
|
|
idLib::FatalError( "idBitMsg::WriteBits: cannot write to message" );
|
|
}
|
|
|
|
// check if the number of bits is valid
|
|
if( numBits == 0 || numBits < -31 || numBits > 32 )
|
|
{
|
|
idLib::FatalError( "idBitMsg::WriteBits: bad numBits %i", numBits );
|
|
}
|
|
|
|
// check for value overflows
|
|
if( numBits != 32 )
|
|
{
|
|
if( numBits > 0 )
|
|
{
|
|
if( value > ( 1 << numBits ) - 1 )
|
|
{
|
|
idLib::FatalError( "idBitMsg::WriteBits: value overflow %d %d",
|
|
value, numBits );
|
|
|
|
}
|
|
else if( value < 0 )
|
|
{
|
|
idLib::FatalError( "idBitMsg::WriteBits: value overflow %d %d",
|
|
value, numBits );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const unsigned shift = ( -1 - numBits );
|
|
int r = 1 << shift;
|
|
if( value > r - 1 )
|
|
{
|
|
idLib::FatalError( "idBitMsg::WriteBits: value overflow %d %d",
|
|
value, numBits );
|
|
|
|
}
|
|
else if( value < -r )
|
|
{
|
|
idLib::FatalError( "idBitMsg::WriteBits: value overflow %d %d",
|
|
value, numBits );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( numBits < 0 )
|
|
{
|
|
numBits = -numBits;
|
|
}
|
|
|
|
// check for msg overflow
|
|
if( CheckOverflow( numBits ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Merge value with possible previous leftover
|
|
tempValue |= ( ( ( int64 )value ) & maskForNumBits64[numBits] ) << writeBit;
|
|
|
|
writeBit += numBits;
|
|
|
|
// Flush 8 bits (1 byte) at a time
|
|
while( writeBit >= 8 )
|
|
{
|
|
writeData[curSize++] = tempValue & 255;
|
|
tempValue >>= 8;
|
|
writeBit -= 8;
|
|
}
|
|
|
|
// Write leftover now, in case this is the last WriteBits call
|
|
if( writeBit > 0 )
|
|
{
|
|
writeData[curSize] = tempValue & 255;
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::WriteString
|
|
========================
|
|
*/
|
|
void idBitMsg::WriteString( const char* s, int maxLength, bool make7Bit )
|
|
{
|
|
if( !s )
|
|
{
|
|
WriteData( "", 1 );
|
|
}
|
|
else
|
|
{
|
|
int i, l;
|
|
byte* dataPtr;
|
|
const byte* bytePtr;
|
|
|
|
l = idStr::Length( s );
|
|
if( maxLength >= 0 && l >= maxLength )
|
|
{
|
|
l = maxLength - 1;
|
|
}
|
|
dataPtr = GetByteSpace( l + 1 );
|
|
bytePtr = reinterpret_cast< const byte* >( s );
|
|
if( make7Bit )
|
|
{
|
|
for( i = 0; i < l; i++ )
|
|
{
|
|
if( bytePtr[i] > 127 )
|
|
{
|
|
dataPtr[i] = '.';
|
|
}
|
|
else
|
|
{
|
|
dataPtr[i] = bytePtr[i];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( i = 0; i < l; i++ )
|
|
{
|
|
dataPtr[i] = bytePtr[i];
|
|
}
|
|
}
|
|
dataPtr[i] = '\0';
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::WriteData
|
|
========================
|
|
*/
|
|
void idBitMsg::WriteData( const void* data, int length )
|
|
{
|
|
memcpy( GetByteSpace( length ), data, length );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::WriteNetadr
|
|
========================
|
|
*/
|
|
void idBitMsg::WriteNetadr( const netadr_t adr )
|
|
{
|
|
WriteData( adr.ip, 4 );
|
|
WriteUShort( adr.port );
|
|
WriteByte( adr.type );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::WriteDeltaDict
|
|
========================
|
|
*/
|
|
bool idBitMsg::WriteDeltaDict( const idDict& dict, const idDict* base )
|
|
{
|
|
int i;
|
|
const idKeyValue* kv, *basekv;
|
|
bool changed = false;
|
|
|
|
if( base != NULL )
|
|
{
|
|
|
|
for( i = 0; i < dict.GetNumKeyVals(); i++ )
|
|
{
|
|
kv = dict.GetKeyVal( i );
|
|
basekv = base->FindKey( kv->GetKey() );
|
|
if( basekv == NULL || basekv->GetValue().Icmp( kv->GetValue() ) != 0 )
|
|
{
|
|
WriteString( kv->GetKey() );
|
|
WriteString( kv->GetValue() );
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
WriteString( "" );
|
|
|
|
for( i = 0; i < base->GetNumKeyVals(); i++ )
|
|
{
|
|
basekv = base->GetKeyVal( i );
|
|
kv = dict.FindKey( basekv->GetKey() );
|
|
if( kv == NULL )
|
|
{
|
|
WriteString( basekv->GetKey() );
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
WriteString( "" );
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
for( i = 0; i < dict.GetNumKeyVals(); i++ )
|
|
{
|
|
kv = dict.GetKeyVal( i );
|
|
WriteString( kv->GetKey() );
|
|
WriteString( kv->GetValue() );
|
|
changed = true;
|
|
}
|
|
WriteString( "" );
|
|
|
|
WriteString( "" );
|
|
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::ReadBits
|
|
|
|
If the number of bits is negative a sign is included.
|
|
========================
|
|
*/
|
|
int idBitMsg::ReadBits( int numBits ) const
|
|
{
|
|
int value;
|
|
int valueBits;
|
|
int get;
|
|
int fraction;
|
|
bool sgn;
|
|
|
|
if( !readData )
|
|
{
|
|
idLib::FatalError( "idBitMsg::ReadBits: cannot read from message" );
|
|
}
|
|
|
|
// check if the number of bits is valid
|
|
if( numBits == 0 || numBits < -31 || numBits > 32 )
|
|
{
|
|
idLib::FatalError( "idBitMsg::ReadBits: bad numBits %i", numBits );
|
|
}
|
|
|
|
value = 0;
|
|
valueBits = 0;
|
|
|
|
if( numBits < 0 )
|
|
{
|
|
numBits = -numBits;
|
|
sgn = true;
|
|
}
|
|
else
|
|
{
|
|
sgn = false;
|
|
}
|
|
|
|
// check for overflow
|
|
if( numBits > GetRemainingReadBits() )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
while( valueBits < numBits )
|
|
{
|
|
if( readBit == 0 )
|
|
{
|
|
readCount++;
|
|
}
|
|
get = 8 - readBit;
|
|
if( get > ( numBits - valueBits ) )
|
|
{
|
|
get = ( numBits - valueBits );
|
|
}
|
|
fraction = readData[readCount - 1];
|
|
fraction >>= readBit;
|
|
// this doesn't really do anything: the bits set to 0 here are already shifted to 0
|
|
fraction &= ( 1 << get ) - 1;
|
|
value |= fraction << valueBits;
|
|
|
|
valueBits += get;
|
|
readBit = ( readBit + get ) & 7;
|
|
}
|
|
|
|
if( sgn )
|
|
{
|
|
if( value & ( 1 << ( numBits - 1 ) ) )
|
|
{
|
|
value |= -1 ^ ( ( 1 << numBits ) - 1 );
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::ReadString
|
|
========================
|
|
*/
|
|
int idBitMsg::ReadString( char* buffer, int bufferSize ) const
|
|
{
|
|
int l, c;
|
|
|
|
ReadByteAlign();
|
|
l = 0;
|
|
while( 1 )
|
|
{
|
|
c = ReadByte();
|
|
if( c <= 0 || c >= 255 )
|
|
{
|
|
break;
|
|
}
|
|
// translate all fmt spec to avoid crash bugs in string routines
|
|
if( c == '%' )
|
|
{
|
|
c = '.';
|
|
}
|
|
|
|
// we will read past any excessively long string, so
|
|
// the following data can be read, but the string will
|
|
// be truncated
|
|
if( l < bufferSize - 1 )
|
|
{
|
|
buffer[l] = c;
|
|
l++;
|
|
}
|
|
}
|
|
|
|
buffer[l] = 0;
|
|
return l;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::ReadString
|
|
========================
|
|
*/
|
|
int idBitMsg::ReadString( idStr& str ) const
|
|
{
|
|
ReadByteAlign();
|
|
|
|
int cnt = 0;
|
|
for( int i = readCount; i < curSize; i++ )
|
|
{
|
|
if( readData[i] == 0 )
|
|
{
|
|
break;
|
|
}
|
|
cnt++;
|
|
}
|
|
|
|
str.Clear();
|
|
str.Append( ( const char* )readData + readCount, cnt );
|
|
readCount += cnt + 1;
|
|
|
|
return str.Length();
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::ReadData
|
|
========================
|
|
*/
|
|
int idBitMsg::ReadData( void* data, int length ) const
|
|
{
|
|
int cnt;
|
|
|
|
ReadByteAlign();
|
|
cnt = readCount;
|
|
|
|
if( readCount + length > curSize )
|
|
{
|
|
if( data )
|
|
{
|
|
memcpy( data, readData + readCount, GetRemainingData() );
|
|
}
|
|
readCount = curSize;
|
|
}
|
|
else
|
|
{
|
|
if( data )
|
|
{
|
|
memcpy( data, readData + readCount, length );
|
|
}
|
|
readCount += length;
|
|
}
|
|
|
|
return ( readCount - cnt );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::ReadNetadr
|
|
========================
|
|
*/
|
|
void idBitMsg::ReadNetadr( netadr_t* adr ) const
|
|
{
|
|
ReadData( adr->ip, 4 );
|
|
adr->port = ReadUShort();
|
|
adr->type = ( netadrtype_t ) ReadByte();
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::ReadDeltaDict
|
|
========================
|
|
*/
|
|
bool idBitMsg::ReadDeltaDict( idDict& dict, const idDict* base ) const
|
|
{
|
|
char key[MAX_STRING_CHARS];
|
|
char value[MAX_STRING_CHARS];
|
|
bool changed = false;
|
|
|
|
if( base != NULL )
|
|
{
|
|
dict = *base;
|
|
}
|
|
else
|
|
{
|
|
dict.Clear();
|
|
}
|
|
|
|
while( ReadString( key, sizeof( key ) ) != 0 )
|
|
{
|
|
ReadString( value, sizeof( value ) );
|
|
dict.Set( key, value );
|
|
changed = true;
|
|
}
|
|
|
|
while( ReadString( key, sizeof( key ) ) != 0 )
|
|
{
|
|
dict.Delete( key );
|
|
changed = true;
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::DirToBits
|
|
========================
|
|
*/
|
|
int idBitMsg::DirToBits( const idVec3& dir, int numBits )
|
|
{
|
|
int max, bits;
|
|
float bias;
|
|
|
|
assert( numBits >= 6 && numBits <= 32 );
|
|
assert( dir.LengthSqr() - 1.0f < 0.01f );
|
|
|
|
numBits /= 3;
|
|
max = ( 1 << ( numBits - 1 ) ) - 1;
|
|
bias = 0.5f / max;
|
|
|
|
bits = IEEE_FLT_SIGNBITSET( dir.x ) << ( numBits * 3 - 1 );
|
|
bits |= ( idMath::Ftoi( ( idMath::Fabs( dir.x ) + bias ) * max ) ) << ( numBits * 2 );
|
|
bits |= IEEE_FLT_SIGNBITSET( dir.y ) << ( numBits * 2 - 1 );
|
|
bits |= ( idMath::Ftoi( ( idMath::Fabs( dir.y ) + bias ) * max ) ) << ( numBits * 1 );
|
|
bits |= IEEE_FLT_SIGNBITSET( dir.z ) << ( numBits * 1 - 1 );
|
|
bits |= ( idMath::Ftoi( ( idMath::Fabs( dir.z ) + bias ) * max ) ) << ( numBits * 0 );
|
|
return bits;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idBitMsg::BitsToDir
|
|
========================
|
|
*/
|
|
idVec3 idBitMsg::BitsToDir( int bits, int numBits )
|
|
{
|
|
static float sign[2] = { 1.0f, -1.0f };
|
|
int max;
|
|
float invMax;
|
|
idVec3 dir;
|
|
|
|
assert( numBits >= 6 && numBits <= 32 );
|
|
|
|
numBits /= 3;
|
|
max = ( 1 << ( numBits - 1 ) ) - 1;
|
|
invMax = 1.0f / max;
|
|
|
|
dir.x = sign[( bits >> ( numBits * 3 - 1 ) ) & 1] * ( ( bits >> ( numBits * 2 ) ) & max )
|
|
* invMax;
|
|
|
|
dir.y = sign[( bits >> ( numBits * 2 - 1 ) ) & 1] * ( ( bits >> ( numBits * 1 ) ) & max )
|
|
* invMax;
|
|
|
|
dir.z = sign[( bits >> ( numBits * 1 - 1 ) ) & 1] * ( ( bits >> ( numBits * 0 ) ) & max )
|
|
* invMax;
|
|
|
|
dir.NormalizeFast();
|
|
return dir;
|
|
}
|