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(unsigned int position, bool relative)
  89         {
  90                 if (!relative)
  91                 {
  92                         if (position > datasize)
  93                                 position = datasize;
  94                         this->position = position;
  95                 }
  96                 else
  97                 {
  98                         if (this->position + position > datasize)
  99                                 position = datasize - this->position;
 100                         this->position += position;
 101                 }
 102         }
 103
 104         int Buffer::readData(void *dest, unsigned int size)
 105         {
 106                 if (datasize - position < size)
 107                 {
 108                         size = datasize - position;
 109                 }
 110                 memcpy(dest, data + position, size);
 111                 position += size;
 112                 return size;
 113         }
 114         int Buffer::writeData(const void *source, unsigned int size, bool resize)
 115         {
 116                 if (this->size - datasize < size)
 117                 {
 118                         if (resize)
 119                         {
 120                                 setSize(datasize + size);
 121                         }
 122                         else
 123                         {
 124                                 size = this->size - datasize;
 125                         }
 126                 }
 127                 memcpy(data + datasize, source, size);
 128                 datasize += size;
 129                 return size;
 130         }
 131
 132         void Buffer::writeInt(int value)
 133         {
 134                 writeData(&value, sizeof(int), true);
 135         }
 136         int Buffer::readInt(void)
 137         {
 138                 int value;
 139                 readData(&value, sizeof(int));
 140                 return value;
 141         }
 142         void Buffer::writeFloat(float value)
 143         {
 144                 writeData(&value, sizeof(float), true);
 145         }
 146         float Buffer::readFloat(void)
 147         {
 148                 float value;
 149                 readData(&value, sizeof(float));
 150                 return value;
 151         }
 152         void Buffer::writeString(std::string str)
 153         {
 154                 writeData(str.c_str(), str.length() + 1, true);
 155         }
 156         std::string Buffer::readString(void)
 157         {
 158                 std::string str = data + position;
 159                 while (readByte())
 160                         ;
 161                 return str;
 162         }
 163         void Buffer::writeByte(unsigned char value)
 164         {
 165                 writeData(&value, sizeof(unsigned char), true);
 166         }
 167         unsigned char Buffer::readByte(void)
 168         {
 169                 unsigned char value;
 170                 readData(&value, sizeof(unsigned char));
 171                 return value;
 172         }
 173         void Buffer::writeWord(short value)
 174         {
 175                 writeData(&value, sizeof(short), true);
 176         }
 177         short Buffer::readWord(void)
 178         {
 179                 short value;
 180                 readData(&value, sizeof(short));
 181                 return value;
 182         }
 183         void Buffer::writeBool(bool flag)
 184         {
 185                 writeByte(flag);
 186         }
 187         bool Buffer::readBool(void)
 188         {
 189                 bool flag = readByte();
 190                 return flag;
 191         }
 192         void Buffer::writeVector2D(Vector2D v)
 193         {
 194                 writeFloat(v.x);
 195                 writeFloat(v.y);
 196         }
 197         Vector2D Buffer::readVector2D(void)
 198         {
 199                 Vector2D v;
 200                 v.x = readFloat();
 201                 v.y = readFloat();
 202                 return v;
 203         }
 204         void Buffer::writeVector3D(Vector3D v)
 205         {
 206                 writeFloat(v.x);
 207                 writeFloat(v.y);
 208                 writeFloat(v.z);
 209         }
 210         Vector3D Buffer::readVector3D(void)
 211         {
 212                 Vector3D v;
 213                 v.x = readFloat();
 214                 v.y = readFloat();
 215                 v.z = readFloat();
 216                 return v;
 217         }
 218         void Buffer::writeQuaternion(Quaternion q)
 219         {
 220                 writeWord((unsigned short)(q.x * (1<<15)));
 221                 writeWord((unsigned short)(q.y * (1<<15)));
 222                 writeWord((unsigned short)(q.z * (1<<15)));
 223                 writeWord((unsigned short)(q.w * (1<<15)));
 224         }
 225         Quaternion Buffer::readQuaternion(void)
 226         {
 227                 Quaternion q;
 228                 q.x = (float)readWord() / (1<<15);
 229                 q.y = (float)readWord() / (1<<15);
 230                 q.z = (float)readWord() / (1<<15);
 231                 q.w = (float)readWord() / (1<<15);
 232                 return q;
 233         }
 234
 235
 236         char *Buffer::getData(void)
 237         {
 238                 return data;
 239         }
 240
 241         void Buffer::clear(void)
 242         {
 243                 if (data)
 244                         free(data);
 245                 data = 0;
 246                 size = 0;
 247                 datasize = 0;
 248                 position = 0;
 249         }
 250
 251         Buffer &Buffer::operator=(const Buffer &buf)
 252         {
 253                 clear();
 254                 *this += buf;
 255                 return *this;
 256         }
 257         Buffer &Buffer::operator+=(const Buffer &buf)
 258         {
 259                 writeData(buf.data, buf.datasize, true);
 260                 return *this;
 261         }
 262         Buffer &Buffer::operator<<(const Buffer &buf)
 263         {
 264                 writeData(buf.data, buf.datasize, true);
 265                 return *this;
 266         }
 267         Buffer &Buffer::operator<<(int &data)
 268         {
 269                 writeData(&data, sizeof(int), true);
 270                 return *this;
 271         }
 272         Buffer &Buffer::operator<<(float &data)
 273         {
 274                 writeData(&data, sizeof(float), true);
 275                 return *this;
 276         }
 277 }
 278