class BufferReader
{
public:
    BufferReader( void *buf, int size ) :
        m_pBuf( (uint8_t*)buf ), m_iSize( size ), m_iRead( 0 ), m_bBad( false ) {}

    template<typename T>
    T Read( void )
    {
        if( m_bBad )
            return -1;

        // don't go out of bounds
        if( m_iRead + sizeof( T ) > m_iSize )
        {
            m_bBad = true;
            return -1;
        }

        if( sizeof( T ) == 1 )
            return m_pBuf[m_iRead++];

        T t = *(T*)(m_pBuf + m_iRead);
        m_iRead += sizeof( T );

        return t;
    }


    int8_t ReadChar( void )
    {
        return Read<int8_t>();
    }

    uint8_t ReadByte( void )
    {
        return Read<uint8_t>();
    }

    int16_t ReadShort( void )
    {
        return Read<int16_t>();
    }

    int16_t ReadWord( void )
    {
        return ReadShort();
    }

    int32_t ReadLong( void )
    {
        return Read<int32_t>();
    }

    char *ReadString( void );
    float ReadFloat( void );
    float ReadCoord( void )
    {
        return Read<short>() * 0.125f;
    }

    float ReadAngle( void )
    {
        return Read<char>() * 360.0f / 256.0f;
    }

    float ReadHiResAngle( void )
    {
        return Read<short>() * 360.0f / 65536.0f;
    }

private:
    uint8_t *m_pBuf;
    size_t m_iSize;
    size_t m_iRead;
    bool m_bBad;
};

template<> inline char* BufferReader::Read( void )
{
    static char string[2048];

    if( m_bBad )
        return nullptr;

    size_t l;
    for( l = 0; l < sizeof(string) - 1; l++)
    {
        if( m_iRead > m_iSize )
            break;

        int8_t c = ReadChar();
        if( c == -1 || c == 0 )
            break;

        string[l] = c;
    }

    string[l] = 0;

    return string;

}

template<> inline float BufferReader::Read( void )
{
    union
    {
        unsigned char b[4];
        float f;
    } tr;

    if( m_bBad )
        return -1.0f;

    if( m_iRead + 4 > m_iSize )
    {
        m_bBad = true;
        return -1.0f;
    }

    for( int i = 0; i < 4; i++ )
        tr.b[i] = m_pBuf[m_iRead + i];

    m_iRead += 4;

    return tr.f;
}

inline char * BufferReader::ReadString( void )
{
    return Read<char*>();
}

inline float BufferReader::ReadFloat( void )
{
    return Read<float>();
}

#define BEGIN_READ(x, y) BufferReader reader( x, y )
#define READ_CHAR() reader.ReadChar()
#define READ_BYTE() reader.ReadByte()
#define READ_SHORT() reader.ReadShort()
#define READ_WORD() reader.ReadWord()
#define READ_LONG() reader.ReadLong()
#define READ_FLOAT() reader.ReadFloat()
#define READ_COORD() reader.ReadCoord()
#define READ_ANGLE() reader.ReadAngle()
#define READ_HIRESANGLE() reader.ReadHiResAngle()
#define READ_STRING() reader.ReadString()