/*
=================
ProcessTexinfo
=================
*/
static void ProcessTexinfo(bsp_t *bsp)
{
mtexinfo_t *tex;
int i;
vec_t len1, len2;
char name[MAX_QPATH];
tex = bsp->texinfo;
for (i = 0; i < bsp->numtexinfo; i++, tex++) {
len1 = VectorLength(tex->axis[0]);
len2 = VectorLength(tex->axis[1]);
len1 = (len1 + len2) / 2;
if (len1 < 0.32)
tex->mipadjust = 4;
else if (len1 < 0.49)
tex->mipadjust = 3;
else if (len1 < 0.99)
tex->mipadjust = 2;
else
tex->mipadjust = 1;
Q_concat(name, sizeof(name), "textures/", tex->name, ".wal", NULL);
FS_NormalizePath(name, name);
tex->image = IMG_Find(name, IT_WALL);
}
}
/*
============
R_SetSky
============
*/
void R_SetSky( const char *name, float rotate, vec3_t axis ) {
int i;
char pathname[MAX_QPATH];
image_t *image;
size_t len;
// 3dstudio environment map names
static const char suf[6][3] = { "rt", "bk", "lf", "ft", "up", "dn" };
if( !gl_drawsky->integer ) {
R_UnsetSky();
return;
}
skyrotate = rotate;
VectorCopy (axis, skyaxis);
for( i = 0; i < 6; i++ ) {
len = Q_concat( pathname, sizeof( pathname ),
"env/", name, suf[i], ".tga", NULL );
if( len >= sizeof( pathname ) ) {
R_UnsetSky();
return;
}
FS_NormalizePath( pathname, pathname );
image = IMG_Find( pathname, it_sky );
if( image->texnum == TEXNUM_DEFAULT ) {
R_UnsetSky();
return;
}
sky_images[i] = image->texnum;
}
}
// Validate a path supplied by a filelist.
static void check_and_queue_download(char *path)
{
size_t len;
char *ext;
dltype_t type;
unsigned flags;
int valid;
len = strlen(path);
if (len >= MAX_QPATH)
return;
ext = strrchr(path, '.');
if (!ext)
return;
ext++;
if (!ext[0])
return;
Q_strlwr(ext);
if (!strcmp(ext, "pak") || !strcmp(ext, "pkz")) {
Com_Printf("[HTTP] Filelist is requesting a .%s file '%s'\n", ext, path);
type = DL_PAK;
} else {
type = DL_OTHER;
if (!CL_CheckDownloadExtension(ext)) {
Com_WPrintf("[HTTP] Illegal file type '%s' in filelist.\n", path);
return;
}
}
if (path[0] == '@') {
if (type == DL_PAK) {
Com_WPrintf("[HTTP] '@' prefix used on a pak file '%s' in filelist.\n", path);
return;
}
flags = FS_PATH_GAME;
path++;
len--;
} else if (type == DL_PAK) {
//by definition paks are game-local
flags = FS_PATH_GAME | FS_TYPE_REAL;
} else {
flags = 0;
}
len = FS_NormalizePath(path, path);
if (len == 0)
return;
valid = FS_ValidatePath(path);
if (valid == PATH_INVALID ||
!Q_ispath(path[0]) ||
!Q_ispath(path[len - 1]) ||
strstr(path, "..") ||
(type == DL_OTHER && !strchr(path, '/')) ||
(type == DL_PAK && strchr(path, '/'))) {
Com_WPrintf("[HTTP] Illegal path '%s' in filelist.\n", path);
return;
}
if (FS_FileExistsEx(path, flags))
return;
if (valid == PATH_MIXED_CASE)
Q_strlwr(path);
if (CL_IgnoreDownload(path))
return;
CL_QueueDownload(path, type);
}
/*
=================
Mod_LoadAliasModel
=================
*/
qerror_t MOD_LoadMD2(model_t *model, const void *rawdata, size_t length)
{
dmd2header_t header;
dmd2frame_t *src_frame;
//dmd2trivertx_t *src_vert;
dmd2triangle_t *src_tri;
dmd2stvert_t *src_st;
maliasframe_t *dst_frame;
//maliasvert_t *dst_vert;
maliastri_t *dst_tri;
maliasst_t *dst_st;
char skinname[MAX_QPATH];
char *src_skin;
int i, j;
qerror_t ret;
if (length < sizeof(header)) {
return Q_ERR_FILE_TOO_SMALL;
}
// byte swap the header
header = *(dmd2header_t *)rawdata;
for (i = 0; i < sizeof(header) / 4; i++) {
((uint32_t *)&header)[i] = LittleLong(((uint32_t *)&header)[i]);
}
// validate the header
ret = MOD_ValidateMD2(&header, length);
if (ret) {
if (ret == Q_ERR_TOO_FEW) {
// empty models draw nothing
model->type = MOD_EMPTY;
return Q_ERR_SUCCESS;
}
return ret;
}
Hunk_Begin(&model->hunk, 0x400000);
model->type = MOD_ALIAS;
// load triangle indices
model->tris = MOD_Malloc(header.num_tris * sizeof(maliastri_t));
model->numtris = header.num_tris;
src_tri = (dmd2triangle_t *)((byte *)rawdata + header.ofs_tris);
dst_tri = model->tris;
for (i = 0; i < header.num_tris; i++, src_tri++, dst_tri++) {
for (j = 0; j < 3; j++) {
unsigned idx_xyz = LittleShort(src_tri->index_xyz[j]);
unsigned idx_st = LittleShort(src_tri->index_st[j]);
if (idx_xyz >= header.num_xyz || idx_st >= header.num_st) {
ret = Q_ERR_BAD_INDEX;
goto fail;
}
dst_tri->index_xyz[j] = idx_xyz;
dst_tri->index_st[j] = idx_st;
}
}
// load base s and t vertices
model->sts = MOD_Malloc(header.num_st * sizeof(maliasst_t));
model->numsts = header.num_st;
src_st = (dmd2stvert_t *)((byte *)rawdata + header.ofs_st);
dst_st = model->sts;
for (i = 0; i < header.num_st; i++, src_st++, dst_st++) {
dst_st->s = (int16_t)LittleShort(src_st->s);
dst_st->t = (int16_t)LittleShort(src_st->t);
}
// load the frames
model->frames = MOD_Malloc(header.num_frames * sizeof(maliasframe_t));
model->numframes = header.num_frames;
model->numverts = header.num_xyz;
src_frame = (dmd2frame_t *)((byte *)rawdata + header.ofs_frames);
dst_frame = model->frames;
for (i = 0; i < header.num_frames; i++, dst_frame++) {
for (j = 0; j < 3; j++) {
dst_frame->scale[j] = LittleFloat(src_frame->scale[j]);
dst_frame->translate[j] = LittleFloat(src_frame->translate[j]);
}
// verts are all 8 bit, so no swapping needed
dst_frame->verts = MOD_Malloc(header.num_xyz * sizeof(maliasvert_t));
// TODO: check normal indices
memcpy(dst_frame->verts, src_frame->verts, header.num_xyz * sizeof(maliasvert_t));
src_frame = (dmd2frame_t *)((byte *)src_frame + header.framesize);
}
// register all skins
src_skin = (char *)rawdata + header.ofs_skins;
for (i = 0; i < header.num_skins; i++) {
if (!Q_memccpy(skinname, src_skin, 0, sizeof(skinname))) {
ret = Q_ERR_STRING_TRUNCATED;
goto fail;
}
FS_NormalizePath(skinname, skinname);
model->skins[i] = IMG_Find(skinname, IT_SKIN);
src_skin += MD2_MAX_SKINNAME;
}
model->numskins = header.num_skins;
Hunk_End(&model->hunk);
return Q_ERR_SUCCESS;
fail:
Hunk_Free(&model->hunk);
return ret;
}
