engine/src/core/Buffer.cpp

   1 /*
   2 Copyright (C) 2008  Mathias Gottschlag
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy of
   5 this software and associated documentation files (the "Software"), to deal in the
   6 Software without restriction, including without limitation the rights to use,
   7 copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
   8 Software, and to permit persons to whom the Software is furnished to do so,
   9 subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in all
  12 copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  15 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  17 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  18 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  19 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20 */
  21
  22 #include "core/Buffer.h"
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 namespace peak
  28 {
  29         Buffer::Buffer()
  30         {
  31                 data = 0;
  32                 size = 0;
  33                 position = 0;
  34                 datasize = 0;
  35         }
  36         Buffer::Buffer(unsigned int size)
  37         {
  38                 data = (char*)malloc(size);
  39                 size = size;
  40                 position = 0;
  41                 datasize = 0;
  42         }
  43         Buffer::Buffer(void *data, unsigned int size)
  44         {
  45                 this->data = (char*)malloc(size);
  46                 size = size;
  47                 datasize = size;
  48                 position = 0;
  49                 memcpy(this->data, data, size);
  50         }
  51         Buffer::Buffer(const Buffer &buf)
  52         {
  53                 data = 0;
  54                 size = 0;
  55                 datasize = 0;
  56                 position = 0;
  57                 *this += buf;
  58         }
  59         Buffer::~Buffer()
  60         {
  61                 if (data)
  62                         free(data);
  63         }
  64
  65         void Buffer::setSize(unsigned int size)
  66         {
  67                 data = (char*)realloc(data, size);
  68                 if (datasize > size)
  69                         datasize = size;
  70                 if (position > datasize)
  71                         position = datasize;
  72                 this->size = size;
  73
  74         }
  75         unsigned int Buffer::getSize(void)
  76         {
  77                 return size;
  78         }
  79         unsigned int Buffer::getDataSize(void)
  80         {
  81                 return datasize;
  82         }
  83
  84         unsigned int Buffer::getPosition(void)
  85         {
  86                 return position;
  87         }
  88         void Buffer::setPosition(int position, bool relative)
  89         {
  90                 if (!relative)
  91                 {
  92                         if (position < 0) position = 0;
  93                         if (position > (int)datasize)
  94                                 position = datasize;
  95                         this->position = position;
  96                 }
  97                 else
  98                 {
  99                         if (this->position + position > datasize)
 100                                 position = datasize - this->position;
 101                         if ((int)this->position + position < 0)
 102                                 position = -this->position;
 103                         this->position = (int)this->position + position;
 104                 }
 105         }
 106
 107         int Buffer::readData(void *dest, unsigned int size)
 108         {
 109                 if (datasize - position < size)
 110                 {
 111                         size = datasize - position;
 112                 }
 113                 memcpy(dest, data + position, size);
 114                 position += size;
 115                 return size;
 116         }
 117         int Buffer::writeData(const void *source, unsigned int size, bool resize)
 118         {
 119                 if (this->size - datasize < size)
 120                 {
 121                         if (resize)
 122                         {
 123                                 setSize(datasize + size);
 124                         }
 125                         else
 126                         {
 127                                 size = this->size - datasize;
 128                         }
 129                 }
 130                 memcpy(data + datasize, source, size);
 131                 datasize += size;
 132                 return size;
 133         }
 134
 135         void Buffer::writeInt(int value)
 136         {
 137                 writeData(&value, sizeof(int), true);
 138         }
 139         int Buffer::readInt(void)
 140         {
 141                 int value;
 142                 readData(&value, sizeof(int));
 143                 return value;
 144         }
 145         void Buffer::writeFloat(float value)
 146         {
 147                 writeData(&value, sizeof(float), true);
 148         }
 149         float Buffer::readFloat(void)
 150         {
 151                 float value;
 152                 readData(&value, sizeof(float));
 153                 return value;
 154         }
 155         void Buffer::writeString(std::string str)
 156         {
 157                 writeData(str.c_str(), str.length() + 1, true);
 158         }
 159         std::string Buffer::readString(void)
 160         {
 161                 std::string str = data + position;
 162                 while (readByte())
 163                         ;
 164                 return str;
 165         }
 166         void Buffer::writeByte(unsigned char value)
 167         {
 168                 writeData(&value, sizeof(unsigned char), true);
 169         }
 170         unsigned char Buffer::readByte(void)
 171         {
 172                 unsigned char value;
 173                 readData(&value, sizeof(unsigned char));
 174                 return value;
 175         }
 176         void Buffer::writeWord(short value)
 177         {
 178                 writeData(&value, sizeof(short), true);
 179         }
 180         short Buffer::readWord(void)
 181         {
 182                 short value;
 183                 readData(&value, sizeof(short));
 184                 return value;
 185         }
 186         void Buffer::writeBool(bool flag)
 187         {
 188                 writeByte(flag);
 189         }
 190         bool Buffer::readBool(void)
 191         {
 192                 bool flag = readByte();
 193                 return flag;
 194         }
 195         void Buffer::writeVector2D(Vector2D v)
 196         {
 197                 writeFloat(v.x);
 198                 writeFloat(v.y);
 199         }
 200         Vector2D Buffer::readVector2D(void)
 201         {
 202                 Vector2D v;
 203                 v.x = readFloat();
 204                 v.y = readFloat();
 205                 return v;
 206         }
 207         void Buffer::writeVector3D(Vector3D v)
 208         {
 209                 writeFloat(v.x);
 210                 writeFloat(v.y);
 211                 writeFloat(v.z);
 212         }
 213         Vector3D Buffer::readVector3D(void)
 214         {
 215                 Vector3D v;
 216                 v.x = readFloat();
 217                 v.y = readFloat();
 218                 v.z = readFloat();
 219                 return v;
 220         }
 221         void Buffer::writeQuaternion(Quaternion q)
 222         {
 223                 writeWord((unsigned short)(q.x * (1<<15)));
 224                 writeWord((unsigned short)(q.y * (1<<15)));
 225                 writeWord((unsigned short)(q.z * (1<<15)));
 226                 writeWord((unsigned short)(q.w * (1<<15)));
 227         }
 228         Quaternion Buffer::readQuaternion(void)
 229         {
 230                 Quaternion q;
 231                 q.x = (float)readWord() / (1<<15);
 232                 q.y = (float)readWord() / (1<<15);
 233                 q.z = (float)readWord() / (1<<15);
 234                 q.w = (float)readWord() / (1<<15);
 235                 return q;
 236         }
 237
 238
 239         char *Buffer::getData(void)
 240         {
 241                 return data;
 242         }
 243
 244         void Buffer::clear(void)
 245         {
 246                 if (data)
 247                         free(data);
 248                 data = 0;
 249                 size = 0;
 250                 datasize = 0;
 251                 position = 0;
 252         }
 253
 254         Buffer &Buffer::operator=(const Buffer &buf)
 255         {
 256                 clear();
 257                 *this += buf;
 258                 return *this;
 259         }
 260         Buffer &Buffer::operator+=(const Buffer &buf)
 261         {
 262                 writeData(buf.data, buf.datasize, true);
 263                 return *this;
 264         }
 265         Buffer &Buffer::operator<<(const Buffer &buf)
 266         {
 267                 writeData(buf.data, buf.datasize, true);
 268                 return *this;
 269         }
 270         Buffer &Buffer::operator<<(int &data)
 271         {
 272                 writeData(&data, sizeof(int), true);
 273                 return *this;
 274         }
 275         Buffer &Buffer::operator<<(float &data)
 276         {
 277                 writeData(&data, sizeof(float), true);
 278                 return *this;
 279         }
 280 }
 281