void BinaryMeshFileReader::read_face(ReaderAdapter& reader, IMeshBuilder& builder)
{
uint16 count;
checked_read(reader, count);
ensure_minimum_size(m_vertices, count);
ensure_minimum_size(m_vertex_normals, count);
ensure_minimum_size(m_tex_coords, count);
for (uint16 i = 0; i < count; ++i)
{
uint32 face_vertex;
checked_read(reader, face_vertex);
m_vertices[i] = face_vertex;
uint32 face_vertex_normal;
checked_read(reader, face_vertex_normal);
m_vertex_normals[i] = face_vertex_normal;
uint32 face_tex_coords;
checked_read(reader, face_tex_coords);
m_tex_coords[i] = face_tex_coords;
}
uint16 material;
checked_read(reader, material);
builder.begin_face(count);
builder.set_face_vertices(&m_vertices[0]);
builder.set_face_vertex_normals(&m_vertex_normals[0]);
builder.set_face_vertex_tex_coords(&m_tex_coords[0]);
builder.set_face_material(material);
builder.end_face();
}
bool LZOCompressedReaderAdapter::fill_buffer()
{
size_t buffer_size;
if (read_uint64(m_file, buffer_size) == 0)
return false;
ensure_minimum_size(m_buffer, buffer_size);
lzo_uint compressed_buffer_size;
read_uint64(m_file, compressed_buffer_size);
ensure_minimum_size(m_compressed_buffer, compressed_buffer_size);
m_file.read(&m_compressed_buffer[0], compressed_buffer_size);
lzo_uint new_buffer_end;
lzo1x_decompress(
&m_compressed_buffer[0],
compressed_buffer_size,
&m_buffer[0],
&new_buffer_end,
&m_working_memory[0]);
m_buffer_index = 0;
m_buffer_end = static_cast<size_t>(new_buffer_end);
return true;
}
void insert_tex_coords_into_mesh()
{
const size_t face_tex_coord_index_count = m_face_tex_coord_indices.size();
for (size_t i = 0; i < face_tex_coord_index_count; ++i)
{
const size_t tex_coord_index = m_face_tex_coord_indices[i];
ensure_minimum_size(m_tex_coord_index_mapping, tex_coord_index + 1, Undefined);
if (m_tex_coord_index_mapping[tex_coord_index] == Undefined)
m_tex_coord_index_mapping[tex_coord_index] = m_builder.push_tex_coords(m_tex_coords[tex_coord_index]);
}
}
void insert_vertex_normals_into_mesh()
{
const size_t face_normal_index_count = m_face_normal_indices.size();
for (size_t i = 0; i < face_normal_index_count; ++i)
{
const size_t normal_index = m_face_normal_indices[i];
ensure_minimum_size(m_normal_index_mapping, normal_index + 1, Undefined);
if (m_normal_index_mapping[normal_index] == Undefined)
m_normal_index_mapping[normal_index] = m_builder.push_vertex_normal(m_normals[normal_index]);
}
}
bool LZ4CompressedReaderAdapter::fill_buffer()
{
size_t buffer_size;
if (read_uint64(m_file, buffer_size) == 0)
return false;
ensure_minimum_size(m_buffer, buffer_size);
size_t compressed_buffer_size;
read_uint64(m_file, compressed_buffer_size);
ensure_minimum_size(m_compressed_buffer, compressed_buffer_size);
m_file.read(&m_compressed_buffer[0], compressed_buffer_size);
LZ4_decompress_fast(
reinterpret_cast<const char*>(&m_compressed_buffer[0]),
reinterpret_cast<char*>(&m_buffer[0]),
static_cast<int>(buffer_size));
m_buffer_index = 0;
m_buffer_end = buffer_size;
return true;
}
size_t CompressedWriterAdapter::write(
const void* inbuf,
const size_t size)
{
if (size > 0)
{
ensure_minimum_size(m_buffer, m_buffer_index + size);
memcpy(&m_buffer[m_buffer_index], inbuf, size);
m_buffer_index += size;
if (m_buffer_index >= m_buffer_size)
flush_buffer();
}
return size;
}
void LZ4CompressedWriterAdapter::flush_buffer()
{
const size_t max_compressed_buffer_size =
static_cast<size_t>(LZ4_compressBound(static_cast<int>(m_buffer_index)));
ensure_minimum_size(m_compressed_buffer, max_compressed_buffer_size);
const int compressed_buffer_size =
LZ4_compress(
reinterpret_cast<const char*>(&m_buffer[0]),
reinterpret_cast<char*>(&m_compressed_buffer[0]),
static_cast<int>(m_buffer_index));
m_file.write(static_cast<uint64>(m_buffer_index));
m_file.write(static_cast<uint64>(compressed_buffer_size));
m_file.write(&m_compressed_buffer[0], compressed_buffer_size);
m_buffer_index = 0;
}
void LZOCompressedWriterAdapter::flush_buffer()
{
const size_t max_compressed_buffer_size = m_buffer_index + (m_buffer_index / 16) + 64 + 3;
ensure_minimum_size(m_compressed_buffer, max_compressed_buffer_size);
lzo_uint compressed_buffer_size;
lzo1x_1_compress(
&m_buffer[0],
m_buffer_index,
&m_compressed_buffer[0],
&compressed_buffer_size,
&m_working_memory[0]);
m_file.write(static_cast<uint64>(m_buffer_index));
m_file.write(static_cast<uint64>(compressed_buffer_size));
m_file.write(&m_compressed_buffer[0], compressed_buffer_size);
m_buffer_index = 0;
}
