[774] | 1 | #include "GeoSerializer.h"
|
---|
| 2 |
|
---|
[1009] | 3 | using namespace Geometry;
|
---|
[774] | 4 |
|
---|
[1009] | 5 | //---------------------------------------------------------------------------
|
---|
| 6 | // Constructor.
|
---|
| 7 | //---------------------------------------------------------------------------
|
---|
| 8 | Serializer::Serializer(String name, Mode mode): mMode(mode)
|
---|
[980] | 9 | {
|
---|
[1009] | 10 | char *char_mode = 0;
|
---|
[980] | 11 |
|
---|
[1009] | 12 | switch (mMode)
|
---|
[980] | 13 | {
|
---|
[1009] | 14 | case READ :
|
---|
| 15 | char_mode = "rb";
|
---|
| 16 | break;
|
---|
| 17 | case APPEND:
|
---|
| 18 | char_mode = "a+b";
|
---|
| 19 | break;
|
---|
| 20 | case WRITE:
|
---|
| 21 | char_mode = "wb";
|
---|
| 22 | break;
|
---|
[980] | 23 | }
|
---|
[774] | 24 |
|
---|
[1009] | 25 | mFile = fopen(name.c_str(),char_mode);
|
---|
| 26 | mSize = 0;
|
---|
| 27 |
|
---|
| 28 | assert(mFile);
|
---|
| 29 | }
|
---|
| 30 |
|
---|
| 31 | //---------------------------------------------------------------------------
|
---|
| 32 | // Destroyer.
|
---|
| 33 | //---------------------------------------------------------------------------
|
---|
| 34 | Serializer::~Serializer()
|
---|
| 35 | {
|
---|
| 36 | fflush(mFile);
|
---|
| 37 | fclose(mFile);
|
---|
| 38 | }
|
---|
| 39 |
|
---|
| 40 | //---------------------------------------------------------------------------
|
---|
| 41 | // Write array of floats.
|
---|
| 42 | //---------------------------------------------------------------------------
|
---|
| 43 | void Serializer::WriteArray(const float* const pFloat, size_t count)
|
---|
| 44 | {
|
---|
[774] | 45 | # if GEO_ENDIAN == GEO_ENDIAN_BIG
|
---|
[1009] | 46 | float *float_to_write = (float *)malloc(sizeof(float) * count);
|
---|
| 47 | memcpy(float_to_write, pFloat, sizeof(float) * count);
|
---|
[980] | 48 |
|
---|
[1009] | 49 | flipToLittleEndian(float_to_write, sizeof(float), count);
|
---|
| 50 | writeData(float_to_write, sizeof(float), count);
|
---|
[980] | 51 |
|
---|
[1009] | 52 | free(float_to_write);
|
---|
[774] | 53 | # else
|
---|
[1009] | 54 | WriteData(pFloat, sizeof(float), count);
|
---|
[774] | 55 | # endif
|
---|
[1009] | 56 | }
|
---|
[774] | 57 |
|
---|
[1009] | 58 | //---------------------------------------------------------------------------
|
---|
| 59 | // Write array of shots.
|
---|
| 60 | //---------------------------------------------------------------------------
|
---|
| 61 | void Serializer::WriteArray(const uint16* const pShort, size_t count = 1)
|
---|
| 62 | {
|
---|
[774] | 63 | # if GEO_ENDIAN == GEO_ENDIAN_BIG
|
---|
[1009] | 64 | unsigned short *short_to_write = (unsigned short *)malloc(sizeof(unsigned short) * count);
|
---|
| 65 | memcpy(short_to_write, pShort, sizeof(unsigned short) * count);
|
---|
[980] | 66 |
|
---|
[1009] | 67 | flipToLittleEndian(short_to_write, sizeof(unsigned short), count);
|
---|
| 68 | WriteData(short_to_write, sizeof(unsigned short), count);
|
---|
[980] | 69 |
|
---|
[1009] | 70 | free(short_to_write);
|
---|
[774] | 71 | # else
|
---|
[1009] | 72 | WriteData(pShort, sizeof(unsigned short), count);
|
---|
[774] | 73 | # endif
|
---|
[1009] | 74 | }
|
---|
[980] | 75 |
|
---|
[1009] | 76 | //---------------------------------------------------------------------------
|
---|
| 77 | // Write array of integers.
|
---|
| 78 | //---------------------------------------------------------------------------
|
---|
| 79 | void Serializer::WriteArray(const uint32* const pInt, size_t count = 1)
|
---|
| 80 | {
|
---|
[774] | 81 | # if GEO_ENDIAN == GEO_ENDIAN_BIG
|
---|
[1009] | 82 | unsigned int *int_to_write = (unsigned int *)malloc(sizeof(unsigned int) * count);
|
---|
| 83 | memcpy(int_to_write, pInt, sizeof(unsigned int) * count);
|
---|
[980] | 84 |
|
---|
[1009] | 85 | FlipToLittleEndian(int_to_write, sizeof(unsigned int), count);
|
---|
| 86 | WriteData(int_to_write, sizeof(unsigned int), count);
|
---|
[980] | 87 |
|
---|
[1009] | 88 | free(int_to_write);
|
---|
[774] | 89 | # else
|
---|
[1009] | 90 | WriteData(pInt, sizeof(unsigned int), count);
|
---|
[774] | 91 | # endif
|
---|
[1009] | 92 | }
|
---|
[774] | 93 |
|
---|
[1009] | 94 | //---------------------------------------------------------------------------
|
---|
| 95 | // Write array of booleans.
|
---|
| 96 | //---------------------------------------------------------------------------
|
---|
| 97 | void Serializer::WriteArray(const bool* const pBool, size_t count = 1)
|
---|
| 98 | {
|
---|
| 99 | //TODO: Apple has problems
|
---|
| 100 | WriteData(pBool, sizeof(bool), count);
|
---|
| 101 | }
|
---|
[980] | 102 |
|
---|
[1009] | 103 | //---------------------------------------------------------------------------
|
---|
| 104 | // Write array of Vector3.
|
---|
| 105 | //---------------------------------------------------------------------------
|
---|
| 106 | void Serializer::WriteArray(const Vector3* const pDest, size_t count)
|
---|
| 107 | {
|
---|
| 108 | for(size_t i = 0; i < count; ++i)
|
---|
[980] | 109 | {
|
---|
[1009] | 110 | WriteArray(pDest[i].val,3);
|
---|
[980] | 111 | }
|
---|
[1009] | 112 | }
|
---|
[980] | 113 |
|
---|
[1009] | 114 | //---------------------------------------------------------------------------
|
---|
| 115 | // Write array of Vector2.
|
---|
| 116 | //---------------------------------------------------------------------------
|
---|
| 117 | void Serializer::WriteArray(const Vector2* const pDest, size_t count)
|
---|
| 118 | {
|
---|
| 119 | for(size_t i = 0; i < count; ++i)
|
---|
[980] | 120 | {
|
---|
[1009] | 121 | WriteArray(pDest[i].val,2);
|
---|
[980] | 122 | }
|
---|
[1009] | 123 | }
|
---|
[774] | 124 |
|
---|
[1009] | 125 | //---------------------------------------------------------------------------
|
---|
| 126 | // Write data.
|
---|
| 127 | //---------------------------------------------------------------------------
|
---|
| 128 | void Serializer::WriteData(const void* const buf, size_t size, size_t count)
|
---|
| 129 | {
|
---|
| 130 | size_t wcount = fwrite((void* const)buf, size, count, mFile);
|
---|
| 131 | assert(wcount == count);
|
---|
| 132 | mSize += size*count;
|
---|
| 133 | }
|
---|
[774] | 134 |
|
---|
[1009] | 135 | //---------------------------------------------------------------------------
|
---|
| 136 | // Read data.
|
---|
| 137 | //---------------------------------------------------------------------------
|
---|
| 138 | void Serializer::ReadData(void *pDest, size_t size, size_t count)
|
---|
| 139 | {
|
---|
| 140 | size_t rcount = fread(pDest,size,count,mFile);
|
---|
| 141 | assert(rcount == count);
|
---|
| 142 | mSize += size*count;
|
---|
| 143 | }
|
---|
[774] | 144 |
|
---|
[1009] | 145 | //---------------------------------------------------------------------------
|
---|
| 146 | // Read data.
|
---|
| 147 | //---------------------------------------------------------------------------
|
---|
| 148 | char * Serializer::ReadData(char *pDest, size_t pDestsize)
|
---|
| 149 | {
|
---|
| 150 | return fgets(pDest, (int)pDestsize, mFile);
|
---|
| 151 | }
|
---|
[774] | 152 |
|
---|
[1009] | 153 | //---------------------------------------------------------------------------
|
---|
| 154 | // Write data.
|
---|
| 155 | //---------------------------------------------------------------------------
|
---|
| 156 | void Serializer::WriteData(const String &string)
|
---|
| 157 | {
|
---|
| 158 | fputs(string.c_str(), mFile);
|
---|
[774] | 159 |
|
---|
[1009] | 160 | // Write terminating newline char
|
---|
| 161 | //fputc('\n', mFile);
|
---|
[774] | 162 |
|
---|
[1009] | 163 | mSize += string.length();
|
---|
| 164 | }
|
---|
[774] | 165 |
|
---|
[1009] | 166 | //---------------------------------------------------------------------------
|
---|
| 167 | // Write string data.
|
---|
| 168 | //---------------------------------------------------------------------------
|
---|
| 169 | void Serializer::WriteData(const char *string)
|
---|
| 170 | {
|
---|
| 171 | fputs(string, mFile);
|
---|
[980] | 172 |
|
---|
[1009] | 173 | // Write terminating newline char
|
---|
| 174 | //fputc('\n', mFile);
|
---|
[774] | 175 |
|
---|
[1009] | 176 | mSize += strlen(string) /*+ 1*/;
|
---|
| 177 | }
|
---|
[774] | 178 |
|
---|
[1009] | 179 | //---------------------------------------------------------------------------
|
---|
| 180 | // Read array of booleans.
|
---|
| 181 | //---------------------------------------------------------------------------
|
---|
| 182 | void Serializer::ReadArray(bool *pDest, size_t count)
|
---|
| 183 | {
|
---|
| 184 | //TODO:: Apple has problmes with bools
|
---|
| 185 | ReadData(pDest,sizeof(bool), count);
|
---|
| 186 | }
|
---|
[980] | 187 |
|
---|
[1009] | 188 | //---------------------------------------------------------------------------
|
---|
| 189 | // Read array of floats.
|
---|
| 190 | //---------------------------------------------------------------------------
|
---|
| 191 | void Serializer::ReadArray(float *pDest, size_t count)
|
---|
| 192 | {
|
---|
| 193 | ReadData(pDest, sizeof(float), count);
|
---|
| 194 | FlipFromLittleEndian(pDest, sizeof(float), count);
|
---|
| 195 | }
|
---|
[774] | 196 |
|
---|
[1009] | 197 | //---------------------------------------------------------------------------
|
---|
| 198 | // Read array of unsigned shots.
|
---|
| 199 | //---------------------------------------------------------------------------
|
---|
| 200 | void Serializer::ReadArray(unsigned short *pDest, size_t count)
|
---|
| 201 | {
|
---|
| 202 | ReadData(pDest, sizeof(unsigned short), count);
|
---|
| 203 | FlipFromLittleEndian(pDest, sizeof(unsigned short), count);
|
---|
| 204 | }
|
---|
[980] | 205 |
|
---|
[1009] | 206 | //---------------------------------------------------------------------------
|
---|
| 207 | // Read array of unsigned integers.
|
---|
| 208 | //---------------------------------------------------------------------------
|
---|
| 209 | void Serializer::ReadArray(unsigned int *pDest, size_t count)
|
---|
| 210 | {
|
---|
| 211 | ReadData(pDest, sizeof(unsigned int), count);
|
---|
| 212 | FlipFromLittleEndian(pDest, sizeof(unsigned int), count);
|
---|
| 213 | }
|
---|
[980] | 214 |
|
---|
[1009] | 215 | //---------------------------------------------------------------------------
|
---|
| 216 | // Read array of Vector3.
|
---|
| 217 | //---------------------------------------------------------------------------
|
---|
| 218 | void Serializer::ReadArray(Vector3 *pDest, size_t count)
|
---|
| 219 | {
|
---|
| 220 | for(size_t i = 0; i < count; ++i)
|
---|
[980] | 221 | {
|
---|
[1009] | 222 | ReadArray(pDest[i].val,3);
|
---|
[980] | 223 | }
|
---|
[1009] | 224 | }
|
---|
[980] | 225 |
|
---|
[1009] | 226 | //---------------------------------------------------------------------------
|
---|
| 227 | // Read array of Vector2.
|
---|
| 228 | //---------------------------------------------------------------------------
|
---|
| 229 | void Serializer::ReadArray(Vector2 *pDest, size_t count)
|
---|
| 230 | {
|
---|
| 231 | for(size_t i = 0; i < count; ++i)
|
---|
[980] | 232 | {
|
---|
[1009] | 233 | ReadArray(pDest[i].val,2);
|
---|
[980] | 234 | }
|
---|
[1009] | 235 | }
|
---|
[774] | 236 |
|
---|
[1009] | 237 | //---------------------------------------------------------------------------
|
---|
| 238 | // Flip to Little Endian.
|
---|
| 239 | //---------------------------------------------------------------------------
|
---|
| 240 | void Serializer::FlipToLittleEndian(void *pData, size_t size, size_t count)
|
---|
| 241 | {
|
---|
[774] | 242 | # if GEO_ENDIAN == GEO_ENDIAN_BIG
|
---|
[1009] | 243 | FlipEndian(pData, size, count);
|
---|
[774] | 244 | # endif
|
---|
[1009] | 245 | }
|
---|
[980] | 246 |
|
---|
[1009] | 247 | //---------------------------------------------------------------------------
|
---|
| 248 | // Flip from Little Endian.
|
---|
| 249 | //---------------------------------------------------------------------------
|
---|
| 250 | void Serializer::FlipFromLittleEndian(void *pData, size_t size, size_t count)
|
---|
| 251 | {
|
---|
[774] | 252 | # if GEO_ENDIAN == GEO_ENDIAN_BIG
|
---|
[1009] | 253 | FlipEndian(pData, size, count);
|
---|
[774] | 254 | # endif
|
---|
[1009] | 255 | }
|
---|
[980] | 256 |
|
---|
[1009] | 257 | //---------------------------------------------------------------------------
|
---|
| 258 | // Flip Endian.
|
---|
| 259 | //---------------------------------------------------------------------------
|
---|
| 260 | void Serializer::FlipEndian(void *pData, size_t size, size_t count)
|
---|
| 261 | {
|
---|
| 262 | for(unsigned int index = 0; index < count; index++)
|
---|
[980] | 263 | {
|
---|
[1009] | 264 | FlipEndian((void *)((char*)pData + (index * size)), size);
|
---|
[980] | 265 | }
|
---|
[1009] | 266 | }
|
---|
[980] | 267 |
|
---|
[1009] | 268 | //---------------------------------------------------------------------------
|
---|
| 269 | // Flip Endian.
|
---|
| 270 | //---------------------------------------------------------------------------
|
---|
| 271 | void Serializer::FlipEndian(void *pData, size_t size)
|
---|
| 272 | {
|
---|
| 273 | char swapByte;
|
---|
| 274 | for(unsigned int byteIndex = 0; byteIndex < size/2; byteIndex++)
|
---|
[980] | 275 | {
|
---|
[1009] | 276 | swapByte = *((char *)pData + byteIndex);
|
---|
| 277 | *((char *)pData + byteIndex) = *((char *)pData + size - byteIndex - 1);
|
---|
| 278 | *((char *)pData + size - byteIndex - 1) = swapByte;
|
---|
[980] | 279 | }
|
---|
[774] | 280 | }
|
---|
| 281 |
|
---|