//---------------------------------------------------------------------
void Writer::writeInts(const uint32* pInt, size_t count)
{
# if OGRE_ENDIAN == OGRE_ENDIAN_BIG
uint32 * pIntToWrite = (uint32 *)malloc(sizeof(uint32) * count);
memcpy(pIntToWrite, pInt, sizeof(uint32) * count);
flipToLittleEndian(pIntToWrite, sizeof(uint32), count);
_write(pIntToWrite, sizeof(uint32), count);
free(pIntToWrite);
# else
_write(pInt, sizeof(uint32), count);
# endif
}
//---------------------------------------------------------------------
void Writer::writeShorts(const uint16* pShort, size_t count)
{
# if OGRE_ENDIAN == OGRE_ENDIAN_BIG
uint16 * pShortToWrite = (uint16 *)malloc(sizeof(uint16) * count);
memcpy(pShortToWrite, pShort, sizeof(uint16) * count);
flipToLittleEndian(pShortToWrite, sizeof(uint16), count);
_write(pShortToWrite, sizeof(uint16), count);
free(pShortToWrite);
# else
_write(pShort, sizeof(uint16), count);
# endif
}
//---------------------------------------------------------------------
void Writer::writeFloats(const float* pFloat, size_t count)
{
# if OGRE_ENDIAN == OGRE_ENDIAN_BIG
float * pFloatToWrite = (float *)malloc(sizeof(float) * count);
memcpy(pFloatToWrite, pFloat, sizeof(float) * count);
flipToLittleEndian(pFloatToWrite, sizeof(float), count);
_write(pFloatToWrite, sizeof(float), count);
free(pFloatToWrite);
# else
_write(pFloat, sizeof(float), count);
# endif
}
//---------------------------------------------------------------------
void Writer::writeFloats(const double* pDouble, size_t count)
{
// Convert to float, then write
float* tmp = new float[count];
for (size_t i = 0; i < count; ++i)
{
tmp[i] = static_cast<float>(pDouble[i]);
}
# if OGRE_ENDIAN == OGRE_ENDIAN_BIG
flipToLittleEndian(tmp, sizeof(float), count);
_write(tmp, sizeof(float), count);
# else
_write(tmp, sizeof(float), count);
# endif
delete [] tmp;
}
//---------------------------------------------------------------------
void Serializer::writeInts(const uint32* const pInt, size_t count = 1)
{
if(mFlipEndian)
{
unsigned int * pIntToWrite = (unsigned int *)malloc(sizeof(unsigned int) * count);
memcpy(pIntToWrite, pInt, sizeof(unsigned int) * count);
flipToLittleEndian(pIntToWrite, sizeof(unsigned int), count);
writeData(pIntToWrite, sizeof(unsigned int), count);
free(pIntToWrite);
}
else
{
writeData(pInt, sizeof(unsigned int), count);
}
}
//---------------------------------------------------------------------
void Serializer::writeShorts(const uint16* const pShort, size_t count = 1)
{
if(mFlipEndian)
{
unsigned short * pShortToWrite = (unsigned short *)malloc(sizeof(unsigned short) * count);
memcpy(pShortToWrite, pShort, sizeof(unsigned short) * count);
flipToLittleEndian(pShortToWrite, sizeof(unsigned short), count);
writeData(pShortToWrite, sizeof(unsigned short), count);
free(pShortToWrite);
}
else
{
writeData(pShort, sizeof(unsigned short), count);
}
}
//---------------------------------------------------------------------
void Serializer::writeFloats(const float* const pFloat, size_t count)
{
if (mFlipEndian)
{
float * pFloatToWrite = (float *)malloc(sizeof(float) * count);
memcpy(pFloatToWrite, pFloat, sizeof(float) * count);
flipToLittleEndian(pFloatToWrite, sizeof(float), count);
writeData(pFloatToWrite, sizeof(float), count);
free(pFloatToWrite);
}
else
{
writeData(pFloat, sizeof(float), count);
}
}
//---------------------------------------------------------------------
void Serializer::writeFloats(const double* const pDouble, size_t count)
{
// Convert to float, then write
float* tmp = OGRE_ALLOC_T(float, count, MEMCATEGORY_GENERAL);
for (unsigned int i = 0; i < count; ++i)
{
tmp[i] = static_cast<float>(pDouble[i]);
}
if(mFlipEndian)
{
flipToLittleEndian(tmp, sizeof(float), count);
writeData(tmp, sizeof(float), count);
}
else
{
writeData(tmp, sizeof(float), count);
}
OGRE_FREE(tmp, MEMCATEGORY_GENERAL);
}
//---------------------------------------------------------------------
void OgreSerializer::writeFloats( const double* const pDouble, size_t count )
{
// Convert to float, then write
float * tmp = new float[ count ];
for ( unsigned int i = 0; i < count; ++i )
{
tmp[ i ] = static_cast<float>( pDouble[ i ] );
}
if ( mFlipEndian )
{
flipToLittleEndian( tmp, sizeof( float ), count );
writeData( tmp, sizeof( float ), count );
}
else
{
writeData( tmp, sizeof( float ), count );
}
delete [] tmp;
}
