void LZ::EncodeNormal(uint8_t *src, uint32_t size, uint32_t lz_mode)
{
for(uint32_t i = 0; i < size; ) {
uint32_t cur_block_size;
cur_block_size = MIN(wnd_size_ - wnd_curpos_, size - i);
cur_block_size = MIN(cur_block_size, MinBlockSize);
memcpy(wnd_ + wnd_curpos_, src + i, cur_block_size);
if (lz_mode == 1) // fast, with no lazy parser
compress_normal(cur_block_size, false);
else if (lz_mode == 2)
compress_normal(cur_block_size, true);
else if (lz_mode == 3)
compress_advanced(cur_block_size);
/*
else if (lz_mode == 4) {
mf_.SetArg(1, 2, 0, good_len_);
compress_normal(cur_block_size, false);
mf_.SetArg(bt_cyc_, ht_cyc_, 1, good_len_);
}*/ else if (lz_mode == 5) {
// only copy the block data to window and put it into MF
// No encoded output
mf_.SetArg(1, 1, 0, good_len_);
compress_mf_skip(cur_block_size);
mf_.SetArg(bt_cyc_, ht_cyc_, 1, good_len_);
} else {
printf("Error!");
exit(0);
}
if (wnd_curpos_ >= wnd_size_)
wnd_curpos_ = 0;
i += cur_block_size;
}
if (lz_mode != 5) {
// for lz_mode == 5, Encode nothing, non terminator
model_->EncodeMatch(64, 0);
}
return;
}
static md2_data_t *md2_process_vertices(const model_t *model, const mesh_t *mesh, int skinwidth, int skinheight)
{
md2_data_t *data;
int i, j, k;
data = (md2_data_t*)qmalloc(sizeof(md2_data_t));
/* convert texcoords to integer and combine duplicates */
data->texcoords = (dstvert_t*)qmalloc(sizeof(dstvert_t) * mesh->num_vertices);
data->numtexcoords = 0;
data->texcoord_lookup = (int*)qmalloc(sizeof(int) * mesh->num_vertices);
for (i = 0; i < mesh->num_vertices; i++)
{
dstvert_t md2texcoord;
md2texcoord.s = (int)(mesh->texcoord2f[i*2+0] * skinwidth);
md2texcoord.t = (int)(mesh->texcoord2f[i*2+1] * skinheight);
for (j = 0; j < data->numtexcoords; j++)
if (md2texcoord.s == data->texcoords[j].s && md2texcoord.t == data->texcoords[j].t)
break;
if (j == data->numtexcoords)
data->texcoords[data->numtexcoords++] = md2texcoord;
data->texcoord_lookup[i] = j;
}
/* compress vertices */
data->frames = (daliasframe_t*)qmalloc(sizeof(daliasframe_t) * model->num_frames);
data->original_vertices = (dtrivertx_t*)qmalloc(sizeof(dtrivertx_t) * mesh->num_vertices * model->num_frames);
for (i = 0; i < model->num_frames; i++)
{
daliasframe_t *md2frame = &data->frames[i];
const float *v, *n;
float mins[3], maxs[3], iscale[3];
/* calculate bounds of frame */
VectorClear(mins);
VectorClear(maxs);
v = mesh->vertex3f + model->frameinfo[i].frames[0].offset * mesh->num_vertices * 3;
for (j = 0; j < mesh->num_vertices; j++, v += 3)
{
for (k = 0; k < 3; k++)
{
mins[k] = (j == 0) ? v[k] : min(mins[k], v[k]);
maxs[k] = (j == 0) ? v[k] : max(maxs[k], v[k]);
}
}
for (j = 0; j < 3; j++)
{
md2frame->scale[j] = (maxs[j] - mins[j]) * (1.0f / 255.0f);
md2frame->translate[j] = mins[j];
iscale[j] = md2frame->scale[j] ? (1.0f / md2frame->scale[j]) : 0.0f;
}
/* compress vertices */
v = mesh->vertex3f + model->frameinfo[i].frames[0].offset * mesh->num_vertices * 3;
n = mesh->normal3f + model->frameinfo[i].frames[0].offset * mesh->num_vertices * 3;
for (j = 0; j < mesh->num_vertices; j++, v += 3, n += 3)
{
dtrivertx_t *md2vertex = &data->original_vertices[j * model->num_frames + i];
for (k = 0; k < 3; k++)
{
float pos = (v[k] - md2frame->translate[k]) * iscale[k];
pos = (float)floor(pos + 0.5f);
pos = bound(0.0f, pos, 255.0f);
md2vertex->v[k] = (unsigned char)pos;
}
md2vertex->lightnormalindex = compress_normal(n);
}
}
/* combine duplicate vertices */
data->vertices = (int*)qmalloc(sizeof(int) * mesh->num_vertices);
data->numvertices = 0;
data->vertex_lookup = (int*)qmalloc(sizeof(int) * mesh->num_vertices);
for (i = 0; i < mesh->num_vertices; i++)
{
const dtrivertx_t *v1 = data->original_vertices + i * model->num_frames;
/* see if a vertex at this position already exists */
for (j = 0; j < data->numvertices; j++)
{
const dtrivertx_t *v2 = data->original_vertices + data->vertices[j] * model->num_frames;
for (k = 0; k < model->num_frames; k++)
if (v1[k].v[0] != v2[k].v[0] || v1[k].v[1] != v2[k].v[1] || v1[k].v[2] != v2[k].v[2] || v1[k].lightnormalindex != v2[k].lightnormalindex)
break;
if (k == model->num_frames)
break;
}
if (j == data->numvertices)
{
/* no match, add this one */
data->vertices[data->numvertices++] = i;
}
data->vertex_lookup[i] = j;
}
return data;
}
