BUFFER.C

Go to the documentation of this file.

/****************************************************************************************/
/*  Buffer.c                                                                            */
/*                                                                                      */
/*  Author: John Pollard                                                                */
/*  Description:                                                                        */
/*                                                                                      */
/*  Copyright (c) 1997, 1999, Eclipse Entertainment; All rights reserved.               */
/*                                                                                      */
/*  See the accompanying file LICENSE.TXT for terms on the use of this library.         */
/*  This library is distributed in the hope that it will be useful but WITHOUT          */
/*  ANY WARRANTY OF ANY KIND and without any implied warranty of MERCHANTABILITY        */
/*  or FITNESS FOR ANY PURPOSE.  Refer to LICENSE.TXT for more details.                 */
/*                                                                                      */
/****************************************************************************************/
#include <Windows.h>
#include <Assert.h>

#include "Genesis.h"

#include "Buffer.h"

typedef struct Pos2
{
        int16   X, Y, Z;
} Pos2;

geBoolean Buffer_FillByte(Buffer_Data *Buffer, uint8 Byte)
{
        assert(Buffer->Pos + (int32)sizeof(uint8) < Buffer->Size);

        if (Buffer->Pos + (int32)sizeof(uint8) >= Buffer->Size)
                return GE_FALSE;

        Buffer->Data[Buffer->Pos] = Byte;

        Buffer->Pos += sizeof(uint8);

        return GE_TRUE;
}

geBoolean Buffer_FillShort(Buffer_Data *Buffer, uint16 Short)
{
        uint16  *Data;

        assert(Buffer->Pos + (int32)sizeof(uint16) < Buffer->Size);

        if (Buffer->Pos + (int32)sizeof(uint16) >= Buffer->Size)
                return GE_FALSE;

        Data = (uint16*)&Buffer->Data[Buffer->Pos];

        *Data = Short;

        Buffer->Pos += sizeof(uint16);

        return GE_TRUE;
}

geBoolean Buffer_FillLong(Buffer_Data *Buffer, uint32 Long)
{
        uint32  *Data;

        assert(Buffer->Pos + (int32)sizeof(uint32) < Buffer->Size);

        if (Buffer->Pos + (int32)sizeof(uint32) >= Buffer->Size)
                return GE_FALSE;

        Data = (uint32*)&Buffer->Data[Buffer->Pos];

        *Data = Long;

        Buffer->Pos += sizeof(uint32);

        return GE_TRUE;
}

geBoolean Buffer_FillSLong(Buffer_Data *Buffer, int32 Long)
{
        int32   *Data;

        assert(Buffer->Pos + (int32)sizeof(int32) < Buffer->Size);

        if (Buffer->Pos + (int32)sizeof(int32) >= Buffer->Size)
                return GE_FALSE;

        Data = (int32*)&Buffer->Data[Buffer->Pos];

        *Data = Long;

        Buffer->Pos += sizeof(int32);

        return GE_TRUE;
}

geBoolean Buffer_FillFloat(Buffer_Data *Buffer, float Float)
{
        float *Data;

        assert(Buffer->Pos + (int32)sizeof(float) < Buffer->Size);

        if (Buffer->Pos + (int32)sizeof(float) >= Buffer->Size)
                return GE_FALSE;

        Data = (float*)&Buffer->Data[Buffer->Pos];

        *Data = Float;

        Buffer->Pos += sizeof(float);

        return GE_TRUE;
}

geBoolean Buffer_FillFloat2(Buffer_Data *Buffer, float Float, float Max)
{
        uint16 *Data;

        assert(Float <= Max);
        assert(Buffer->Pos + (int32)sizeof(uint16) < Buffer->Size);

        if (Buffer->Pos + (int32)sizeof(uint16) >= Buffer->Size)
                return GE_FALSE;

        Data = (uint16*)&Buffer->Data[Buffer->Pos];

        *Data = (uint16)((Float/Max)*65535);

        Buffer->Pos += sizeof(uint16);

        return GE_TRUE;
}

geBoolean Buffer_FillAngle(Buffer_Data *Buffer, geVec3d Angle)
{
        geVec3d *Data;

        assert(Buffer->Pos + (int32)sizeof(geVec3d) < Buffer->Size);
        
        if (Buffer->Pos + (int32)sizeof(geVec3d) >= Buffer->Size)
                return GE_FALSE;

        Data = (geVec3d*)&Buffer->Data[Buffer->Pos];

        *Data = Angle;

        Buffer->Pos += sizeof(geVec3d);

        return GE_TRUE;
}

geBoolean Buffer_FillPos(Buffer_Data *Buffer, geVec3d Pos)
{
        geVec3d         *Data;

        assert(Buffer->Pos + (int32)sizeof(geVec3d) < Buffer->Size);

        if (Buffer->Pos + (int32)sizeof(geVec3d) >= Buffer->Size)
                return GE_FALSE;

        Data = (geVec3d*)&Buffer->Data[Buffer->Pos];

        *Data = Pos;

        Buffer->Pos += sizeof(geVec3d);

        return GE_TRUE;
}

geBoolean Buffer_FillString(Buffer_Data *Buffer, uint8 *Str)
{
        int32           i;

        assert(Buffer->Pos + (int32)strlen((char*)Str)+1 < Buffer->Size);
        
        if (Buffer->Pos + (int32)strlen((char*)Str)+1 >= Buffer->Size)
                return GE_FALSE;

        for (i=0; i< (int32)strlen((char*)Str)+1; i++)
                Buffer->Data[Buffer->Pos++] = Str[i];

        return GE_TRUE;
}

geBoolean Buffer_FillBuffer(Buffer_Data *Buffer1, Buffer_Data *Buffer2)
{
        int32           i;

        assert(Buffer2->Pos + Buffer1->Pos < Buffer1->Size);

        if (Buffer2->Pos + Buffer1->Pos >= Buffer1->Size)
                return GE_FALSE;

        for (i=0; i< Buffer2->Pos; i++)
                Buffer1->Data[Buffer1->Pos++] = Buffer2->Data[i];

        return GE_TRUE;
}

geBoolean Buffer_FillData(Buffer_Data *Buffer1, uint8 *Data, int32 Size)
{
        int32           i;

        assert(Buffer1->Pos + Size < Buffer1->Size);

        if (Buffer1->Pos + Size >= Buffer1->Size)
                return GE_FALSE;

        for (i=0; i< Size; i++)
                Buffer1->Data[Buffer1->Pos++] = Data[i];

        return GE_TRUE;
}

geBoolean Buffer_GetByte(Buffer_Data *Buffer, uint8 *Byte)
{
        assert(Buffer->Pos + (int32)sizeof(uint8) <= Buffer->Size);

        *Byte = Buffer->Data[Buffer->Pos];

        Buffer->Pos += sizeof(uint8);

        return GE_TRUE;
}

geBoolean Buffer_GetShort(Buffer_Data *Buffer, uint16 *Short)
{
        assert(Buffer->Pos + (int32)sizeof(uint16) <= Buffer->Size);

        *Short = *((uint16*)&Buffer->Data[Buffer->Pos]);

        Buffer->Pos += sizeof(uint16);

        return GE_TRUE;
}

geBoolean Buffer_GetLong(Buffer_Data *Buffer, uint32 *Long)
{
        assert(Buffer->Pos + (int32)sizeof(uint32) <= Buffer->Size);

        *Long = *((uint32*)&Buffer->Data[Buffer->Pos]);

        Buffer->Pos += sizeof(uint32);
        
        return GE_TRUE;
}

geBoolean Buffer_GetSLong(Buffer_Data *Buffer, int32 *Long)
{
        assert(Buffer->Pos + (int32)sizeof(int32) <= Buffer->Size);

        *Long = *((int32*)&Buffer->Data[Buffer->Pos]);

        Buffer->Pos += sizeof(int32);
        
        return GE_TRUE;
}

geBoolean Buffer_GetFloat(Buffer_Data *Buffer, float *Float)
{
        assert(Buffer->Pos + (int32)sizeof(float) <= Buffer->Size);

        *Float = *((float*)&Buffer->Data[Buffer->Pos]);

        Buffer->Pos += sizeof(float);
        
        return GE_TRUE;
}

geBoolean Buffer_GetFloat2(Buffer_Data *Buffer, float *Float, float Max)
{
        uint16  Temp16;

        assert(Buffer->Pos + (int32)sizeof(uint16) <= Buffer->Size);

        Temp16 = *((uint16*)&Buffer->Data[Buffer->Pos]);

        *Float = ((float)Temp16 / 65535.0f) * Max;

        Buffer->Pos += sizeof(uint16);
        
        return GE_TRUE;
}

geBoolean Buffer_GetAngle(Buffer_Data *Buffer, geVec3d *Angle)
{
        assert(Buffer->Pos + (int32)sizeof(geVec3d) <= Buffer->Size);

        *Angle = *(geVec3d*)&Buffer->Data[Buffer->Pos];

        Buffer->Pos += sizeof(geVec3d);
        
        return GE_TRUE;
}

geBoolean Buffer_GetPos(Buffer_Data *Buffer, geVec3d *Pos)
{
        assert(Buffer->Pos + (int32)sizeof(geVec3d) <= Buffer->Size);

        *Pos = *(geVec3d*)&Buffer->Data[Buffer->Pos];
        
        Buffer->Pos += sizeof(geVec3d);
        
        return GE_TRUE;
}

geBoolean Buffer_GetString(Buffer_Data *Buffer, uint8 *Str)
{
        int32   i = 0;
        uint8   c = 0;

        do 
        {
                assert(Buffer->Pos+1 <= Buffer->Size);

                c = Buffer->Data[Buffer->Pos++];
                Str[i++] = c;
        } while (c != -1 && c != 0);

        return GE_TRUE;
}

geBoolean Buffer_GetData(Buffer_Data *Buffer1, uint8 *Data, int32 Size)
{
        int32           i;

        assert(Buffer1->Pos + Size <= Buffer1->Size);

        for (i=0; i< Size; i++)
                Data[i] = Buffer1->Data[Buffer1->Pos++];

        return GE_TRUE;
}

geBoolean Buffer_Set(Buffer_Data *Buffer, char *Data, int32 Size)
{
        assert(Buffer);

        Buffer->Data = Data;
        Buffer->Size = Size;
        Buffer->Pos = 0;

        return GE_TRUE;
}

---