/*
=================
Mod_SetParent
=================
*/
void Mod_SetParent (mnode_t *node, mnode_t *parent)
{
node->parent = parent;
if (node->contents < 0)
return;
Mod_SetParent (node->children[0], node);
Mod_SetParent (node->children[1], node);
}
/*
* Mod_SetParent
*/
static void Mod_SetParent( mnode_t *node, mnode_t *parent )
{
node->parent = parent;
if( !node->plane )
return;
Mod_SetParent( node->children[0], node );
Mod_SetParent( node->children[1], node );
}
static void
Mod_SetParent(mnode_t *node, mnode_t *parent)
{
node->parent = parent;
if (node->contents != -1)
{
return;
}
Mod_SetParent(node->children[0], node);
Mod_SetParent(node->children[1], node);
}
void
Mod_LoadNodes(lump_t *l)
{
int i, j, count, p;
dnode_t *in;
mnode_t *out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
ri.Sys_Error(ERR_DROP, "MOD_LoadBmodel: funny lump size in %s",
loadmodel->name);
}
count = l->filelen / sizeof(*in);
out = Hunk_Alloc(count * sizeof(*out));
loadmodel->nodes = out;
loadmodel->numnodes = count;
for (i = 0; i < count; i++, in++, out++)
{
for (j = 0; j < 3; j++)
{
out->minmaxs[j] = LittleShort(in->mins[j]);
out->minmaxs[3 + j] = LittleShort(in->maxs[j]);
}
p = LittleLong(in->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = LittleShort(in->firstface);
out->numsurfaces = LittleShort(in->numfaces);
out->contents = -1; /* differentiate from leafs */
for (j = 0; j < 2; j++)
{
p = LittleLong(in->children[j]);
if (p >= 0)
{
out->children[j] = loadmodel->nodes + p;
}
else
{
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
}
Mod_SetParent(loadmodel->nodes, NULL); /* sets nodes and leafs */
}
/*
=================
Mod_LoadNodes
=================
*/
void Mod_LoadNodes (lump_t *l, FILE *file, long base)
{
int i, j, count, p;
dnode_t in[MAX_MAP_NODES];
mnode_t *out;
Com_DPrintf("%s\n", __FUNCTION__);
fseek(file, base + l->fileofs, SEEK_SET);
if (l->filelen % sizeof(dnode_t))
ri.Sys_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(dnode_t);
if (count > MAX_MAP_NODES)
ri.Sys_Error(ERR_DROP, "%s: Too many (%d) in %s", __FUNCTION__, count, loadmodel->name);
out = Hunk_Alloc (&hunk_ref, count*sizeof(*out));
loadmodel->nodes = out;
loadmodel->numnodes = count;
ri.FS_Read(in, l->filelen, file);
for ( i=0 ; i<count ; i++, out++)
{
dnode_t *pin = &in[i];
for (j=0 ; j<3 ; j++)
{
out->minmaxs[j] = LittleShort (pin->mins[j]);
out->minmaxs[3+j] = LittleShort (pin->maxs[j]);
}
p = LittleLong(pin->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = LittleShort (pin->firstface);
out->numsurfaces = LittleShort (pin->numfaces);
out->contents = -1; // differentiate from leafs
for (j=0 ; j<2 ; j++)
{
p = LittleLong (pin->children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
Com_DPrintf("%s OK\n", __FUNCTION__);
}
/*
=================
Mod_LoadNodes
=================
*/
void Mod_LoadNodes (lump_t *l)
{
int i, j, count, p;
dnode_t *in;
mnode_t *out;
in = (dnode_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
VID_Error (ERR_DROP, "Mod_LoadNodes: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = (mnode_t *) Hunk_Alloc ( count*sizeof(*out));
loadmodel->nodes = out;
loadmodel->numnodes = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
out->minmaxs[0] = LittleShort(in->mins[0]);
out->minmaxs[1] = LittleShort(in->mins[1]);
out->minmaxs[2] = LittleShort(in->mins[2]);
out->minmaxs[3] = LittleShort(in->maxs[0]);
out->minmaxs[4] = LittleShort(in->maxs[1]);
out->minmaxs[5] = LittleShort(in->maxs[2]);
p = LittleLong(in->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = LittleShort(in->firstface);
out->numsurfaces = LittleShort(in->numfaces);
out->contents = -1; // differentiate from leafs
out->parent = NULL;
out->visframe = 0;
for (j=0 ; j<2 ; j++)
{
p = LittleLong(in->children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
}
/*
=================
Mod_LoadNodes
=================
*/
void Mod_LoadNodes (lump_t *l)
{
int i, j, count, p;
dnode_t *in;
mnode_t *out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->nodes = out;
loadmodel->numnodes = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
// for (j=0 ; j<3 ; j++) // l
{
out->minmaxs[0] = LittleShort (in->mins[0]);
out->minmaxs[3+0] = LittleShort (in->maxs[0]);
out->minmaxs[1] = LittleShort (in->mins[1]);
out->minmaxs[3+1] = LittleShort (in->maxs[1]);
out->minmaxs[2] = LittleShort (in->mins[2]);
out->minmaxs[3+2] = LittleShort (in->maxs[2]);
}
p = LittleLong(in->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = LittleShort (in->firstface);
out->numsurfaces = LittleShort (in->numfaces);
for (j=0 ; j<2 ; j++)
{
p = LittleShort (in->children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
}
/*
=================
Mod_LoadNodes
=================
*/
void Mod_LoadNodes (lump_t *l, FILE *file, long base)
{
int i, j, count, p;
dnode_t in;
mnode_t *out;
fseek(file, base + l->fileofs, SEEK_SET);
if (l->filelen % sizeof(in))
ri.Sys_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(in);
out = Hunk_Alloc (&hunk_ref, count*sizeof(*out));
loadmodel->nodes = out;
loadmodel->numnodes = count;
for ( i=0 ; i<count ; i++, out++)
{
ri.FS_Read(&in, sizeof(in), file);
for (j=0 ; j<3 ; j++)
{
out->minmaxs[j] = LittleShort (in.mins[j]);
out->minmaxs[3+j] = LittleShort (in.maxs[j]);
}
p = LittleLong(in.planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = LittleShort (in.firstface);
out->numsurfaces = LittleShort (in.numfaces);
out->contents = -1; // differentiate from leafs
for (j=0 ; j<2 ; j++)
{
p = LittleLong (in.children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
}
/*
=================
Mod_LoadFaces
=================
*/
void Mod_LoadFaces (lump_t *l)
{
dface_t *in;
msurface_t *out;
int i, count, surfnum, planenum, side;
#ifdef BSP23TEST
int size = (mod_bspversion == 23) ? 24 : sizeof(dface_t);
in = (void *)(mod_base + l->fileofs);
if (l->filelen % size)
Host_Error ("Mod_LoadFaces: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / size;
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for (surfnum=0 ; surfnum<count ; surfnum++, out++)
{
out->flags = 0;
planenum = LittleShort(in->planenum);
if ((side = LittleShort(in->side)))
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
if (mod_bspversion == 23)
{
out->firstedge = LittleLong(((dface23_t *)in)->firstedge);
out->numedges = LittleShort(((dface23_t *)in)->numedges);
out->texinfo = NULL; /******* FIXME *******/
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = ((dface23_t *)in)->styles[i];
i = LittleLong(((dface23_t *)in)->lightofs);
}
else
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
CalcSurfaceExtents (loadmodel, out);
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
}
#else
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadFaces: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for (surfnum=0 ; surfnum<count ; surfnum++, in++, out++)
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
out->flags = 0;
// out->visframe = 0; /************ JDH ************/
planenum = LittleShort(in->planenum);
if ((side = LittleShort(in->side)))
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
CalcSurfaceExtents (loadmodel, out);
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
#endif
//out->samples = (i == -1) ? NULL : loadmodel->lightdata + i * 3;
out->samples = (i == -1) ? NULL : loadmodel->lightdata + i * loadmodel->lightdatadepth;
// set the drawing flags flag
if (ISSKYTEX(out->texinfo->texture->name)) // sky
{
out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
GL_SubdivideSurface (loadmodel, out); // cut up polygon for warps
}
else if (ISTURBTEX(out->texinfo->texture->name)) // turbulent
{
out->flags |= (SURF_DRAWTURB | SURF_DRAWTILED);
for (i=0 ; i<2 ; i++)
{
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
GL_SubdivideSurface (loadmodel, out); // cut up polygon for warps
#ifdef HEXEN2_SUPPORT
if (hexen2)
{
if ((!Q_strncasecmp(out->texinfo->texture->name, "*rtex078",8)) ||
(!Q_strncasecmp(out->texinfo->texture->name, "*lowlight",9)))
out->flags |= SURF_TRANSLUCENT;
}
#endif
}
#ifdef BSP23TEST
in = (dface_t *) ((byte *) in + size);
#endif
}
}
#endif //#ifndef RQM_SV_ONLY
#ifdef BSP23TEST
typedef struct
{
int planenum;
short children[2]; // negative numbers are -(leafs+1), not nodes
float mins[3]; // for sphere culling
float maxs[3];
unsigned short firstface;
unsigned short numfaces; // counting both sides
} dnode23_t;
/*
=================
Mod_LoadNodes23
=================
*/
void Mod_LoadNodes23 (lump_t *l)
{
int i, j, count, p;
dnode23_t *in;
mnode_t *out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadNodes23: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->nodes = out;
loadmodel->numnodes = count;
for (i=0 ; i<count ; i++, in++, out++)
{
for (j=0 ; j<3 ; j++)
{
out->minmaxs[j] = LittleFloat (in->mins[j]);
out->minmaxs[3+j] = LittleFloat (in->maxs[j]);
}
p = LittleLong(in->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = (unsigned short) LittleShort (in->firstface);
out->numsurfaces = (unsigned short) LittleShort (in->numfaces);
// out->visframe = 0; /****** JDH ******/
for (j=0 ; j<2 ; j++)
{
p = LittleShort (in->children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
}
/*
=================
Mod_LoadNodes
=================
*/
void Mod_LoadNodes (lump_t *l)
{
int i, j, count, p;
dnode_t *in;
mnode_t *out;
#ifdef BSP23TEST
if (mod_bspversion == 23)
{
Mod_LoadNodes23 (l);
return;
}
#endif
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadNodes: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->nodes = out;
loadmodel->numnodes = count;
for (i=0 ; i<count ; i++, in++, out++)
{
for (j=0 ; j<3 ; j++)
{
// JDH: since these are stored as shorts, they may not be correct
// if map exceeds normal Quake coordinate space (spcscr.bsp)
if (mod_oversized)
{
out->minmaxs[j] = (int)0x7FFFFFFF;
out->minmaxs[3+j] = (int)0x80000000;
}
else
{
out->minmaxs[j] = LittleShort (in->mins[j]);
out->minmaxs[3+j] = LittleShort (in->maxs[j]);
}
}
p = LittleLong(in->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = (unsigned short) LittleShort (in->firstface);
out->numsurfaces = (unsigned short) LittleShort (in->numfaces);
// out->visframe = 0; /****** JDH ******/
#ifndef RQM_SV_ONLY
if (mod_oversized)
{
msurface_t *surf;
for (j = 0, surf = loadmodel->surfaces + out->firstsurface; j < out->numsurfaces; j++, surf++)
{
for (p = 0; p < 3; p++)
{
if (surf->mins[p] < out->minmaxs[p])
out->minmaxs[p] = surf->mins[p];
if (surf->maxs[p] > out->minmaxs[3+p])
out->minmaxs[3+p] = surf->maxs[p];
}
}
}
#endif
for (j=0 ; j<2 ; j++)
{
#if 0
p = LittleShort (in->children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
#else
/* 2011/05/15: fix for oms2_2 */
p = (unsigned short) LittleShort (in->children[j]);
if (p < count)
out->children[j] = loadmodel->nodes + p;
else
{
// JDH: hack for >32767 nodes (thanks DP/Fitz!)
p = 65535 - p;
if (p < loadmodel->numleafs)
out->children[j] = (mnode_t *)(loadmodel->leafs + p);
else
{
Con_Printf("Mod_LoadNodes: invalid leaf index %i (file has only %i leafs)\n", p, loadmodel->numleafs);
out->children[j] = (mnode_t *)(loadmodel->leafs); //map it to the solid leaf
}
}
#endif
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
}
