Serializable* ExporterBackend::buildTexture(CSLImage* image, CSIBCPixMap& pixMap)
{
uint depth = pixMap.GetTotalPixelDepthByte();
// We only handly 32 bit and 24bit textures right now
if (depth != 4 && depth != 3)
{
ZENIC_WARNING("Unsupported pixeldepth (" << pixMap.GetTotalPixelDepthByte() << ") for texture " << image->GetSourceFile() <<
"skipping");
return 0;
}
Texture* texture = zenic_new Texture;
TextureData* textureData = zenic_new TextureData;
textureData->setWidth(u16(pixMap.GetWidth()));
textureData->setHeight(u16(pixMap.GetHeight()));
textureData->setFlags(TextureData::RGB);
DataPtr<u8> imageData;
uint imageSize = pixMap.GetWidth() * pixMap.GetHeight() * depth;
imageData.allocate(imageSize);
memcpy(imageData.objects(), pixMap.GetMap(), imageSize);
textureData->setImageData(imageData);
texture->setData(textureData);
return texture;
}
inline void encodeTypedElements( BinaryPortable *, T *, DataPtr &data, T *t, int nCount)
{
UInt32 nBufferSize = sizeof(T) * nCount;
UInt32 nAlloc = data.allocate(nBufferSize);
RCF_ASSERT(nAlloc == nBufferSize);
T *buffer = reinterpret_cast<T *>(data.get());
memcpy(buffer, t, nBufferSize);
RCF::machineToNetworkOrder(buffer, sizeof(T), nCount);
}
int FifoStream::write(const void* buffer, int size)
{
int maxWrite = 0;
if (m_writing <= m_reading)
maxWrite = (m_reading-m_writing)-1;
else
maxWrite = ((m_reading+m_buffer.count())-m_writing)-1;
if (maxWrite < size)
{
DataPtr<u8> newData;
// TODO: resize 2^x to allow for efficient performance
newData.allocate(m_buffer.count() + (size-maxWrite));
if (m_reading <= m_writing)
{
::memcpy(newData.objects(), &m_buffer.objects()[m_reading], m_writing-m_reading);
m_writing -= m_reading;
m_reading = 0;
}
else
{
// INCORRECT!
::memcpy(newData.objects(), m_buffer.objects() + m_reading, m_buffer.count()-m_reading);
::memcpy(newData.objects() + (m_buffer.count()-m_reading), m_buffer.objects(), m_writing);
m_writing = m_reading-m_writing;
m_reading = 0;
}
m_buffer.free();
m_buffer = newData;
}
int actualWrite = size;
const char* currentBuffer = static_cast<const char*>(buffer);
while (size > 0)
{
int currentWrite = size;
if (uint(m_writing + currentWrite) > m_buffer.count())
currentWrite = m_buffer.count() - m_writing;
::memcpy(m_buffer.objects() + m_writing, currentBuffer, currentWrite);
m_writing += currentWrite;
if (m_buffer.count() == uint(m_writing))
m_writing = 0;
currentBuffer += currentWrite;
size -= currentWrite;
}
return actualWrite;
}
void EncodingBinaryPortable_toDataImpl(
DataPtr & data,
T * t,
int nCount)
{
UInt32 nBufferSize = sizeof(T) * nCount;
UInt32 nAlloc = data.allocate(nBufferSize);
RCF_ASSERT_EQ(nAlloc , nBufferSize);
RCF_UNUSED_VARIABLE(nAlloc);
T *buffer = reinterpret_cast<T *>(data.get());
memcpy(buffer, t, nBufferSize);
RCF::machineToNetworkOrder(buffer, sizeof(T), nCount);
}
bool IStream::get(DataPtr &value)
{
Byte8 byte;
read_byte( byte );
if (byte == Data)
{
UInt32 length = 0;
read_int(length);
value.allocate(length);
read(value.get(), length);
return true;
}
else
{
putback_byte(byte);
return false;
}
}
