/*
============
EmitDrawingNode_r
============
*/
int EmitDrawNode_r( node_t *node ){
dnode_t *n;
face_t *f;
int i;
if ( node->planenum == PLANENUM_LEAF ) {
EmitLeaf( node );
return -numleafs;
}
// emit a node
if ( numnodes == MAX_MAP_NODES ) {
Error( "MAX_MAP_NODES" );
}
n = &dnodes[numnodes];
numnodes++;
VectorCopy( (short) node->mins, n->mins );
VectorCopy( (short) node->maxs, n->maxs );
planeused[node->planenum]++;
planeused[node->planenum ^ 1]++;
if ( node->planenum & 1 ) {
Error( "WriteDrawNodes_r: odd planenum" );
}
n->planenum = node->planenum;
n->firstface = numfaces;
if ( !node->faces ) {
c_nofaces++;
}
else{
c_facenodes++;
}
for ( f = node->faces ; f ; f = f->next )
EmitFace( f );
n->numfaces = numfaces - n->firstface;
//
// recursively output the other nodes
//
for ( i = 0 ; i < 2 ; i++ )
{
if ( node->children[i]->planenum == PLANENUM_LEAF ) {
n->children[i] = -( numleafs + 1 );
EmitLeaf( node->children[i] );
}
else
{
n->children[i] = numnodes;
EmitDrawNode_r( node->children[i] );
}
}
return n - dnodes;
}
/*
============
EmitDrawingNode_r
============
*/
int EmitDrawNode_r (node_t *node)
{
dnode_t *n;
face_t *f;
int i;
if (node->planenum == PLANENUM_LEAF)
{
EmitLeaf (node);
return -numleafs;
}
// emit a node
if (numnodes == MAX_MAP_NODES)
Error ("MAX_MAP_NODES");
node->diskId = numnodes;
n = &dnodes[numnodes];
numnodes++;
VECTOR_COPY (node->mins, n->mins);
VECTOR_COPY (node->maxs, n->maxs);
if (node->planenum & 1)
Error ("WriteDrawNodes_r: odd planenum");
n->planenum = node->planenum;
n->firstface = numfaces;
n->area = node->area;
if (!node->faces)
c_nofaces++;
else
c_facenodes++;
for (f=node->faces ; f ; f=f->next)
EmitFace (f, true);
n->numfaces = numfaces - n->firstface;
//
// recursively output the other nodes
//
for (i=0 ; i<2 ; i++)
{
if (node->children[i]->planenum == PLANENUM_LEAF)
{
n->children[i] = -(numleafs + 1);
EmitLeaf (node->children[i]);
}
else
{
n->children[i] = numnodes;
EmitDrawNode_r (node->children[i]);
}
}
return n - dnodes;
}
/**
* @brief Writes the draw nodes
* @note Called after a drawing hull is completed
*/
static int EmitDrawNode_r (node_t* node)
{
const char* side[2] = {"front", "back"};
dBspNode_t* n;
const face_t* f;
int i;
if (node->planenum == PLANENUM_LEAF) {
Verb_Printf(VERB_DUMP, "EmitDrawNode_r: creating singleton leaf.\n");
EmitLeaf(node);
return -curTile->numleafs;
}
/* emit a node */
if (curTile->numnodes >= MAX_MAP_NODES)
Sys_Error("MAX_MAP_NODES (%i)", curTile->numnodes);
n = &curTile->nodes[curTile->numnodes];
Verb_Printf(VERB_DUMP, "EmitDrawNode_r: creating bsp node %i\n", curTile->numnodes);
curTile->numnodes++;
VectorCopy(node->mins, n->mins);
VectorCopy(node->maxs, n->maxs);
if (node->planenum & 1)
Sys_Error("EmitDrawNode_r: odd planenum: %i", node->planenum);
n->planenum = node->planenum;
n->firstface = curTile->numfaces;
if (!node->faces)
c_nofaces++;
else
c_facenodes++;
for (f = node->faces; f; f = f->next)
EmitFace(f);
n->numfaces = curTile->numfaces - n->firstface;
/* recursively output the other nodes */
for (i = 0; i < 2; i++) {
if (node->children[i]->planenum == PLANENUM_LEAF) {
Verb_Printf(VERB_DUMP, "EmitDrawNode_r: creating child leaf for %s of bsp node " UFO_SIZE_T ".\n", side[i], n - curTile->nodes);
n->children[i] = -(curTile->numleafs + 1);
EmitLeaf(node->children[i]);
} else {
Verb_Printf(VERB_DUMP, "EmitDrawNode_r: adding child node for bsp node " UFO_SIZE_T ".\n", n - curTile->nodes);
n->children[i] = curTile->numnodes;
EmitDrawNode_r(node->children[i]);
}
}
return n - curTile->nodes;
}
/*
* @brief
*/
static int32_t EmitDrawNode_r(node_t * node) {
d_bsp_node_t *n;
face_t *f;
int32_t i;
if (node->plane_num == PLANENUM_LEAF) {
EmitLeaf(node);
return -d_bsp.num_leafs;
}
// emit a node
if (d_bsp.num_nodes == MAX_BSP_NODES)
Com_Error(ERR_FATAL, "MAX_BSP_NODES\n");
n = &d_bsp.nodes[d_bsp.num_nodes];
d_bsp.num_nodes++;
VectorCopy(node->mins, n->mins);
VectorCopy(node->maxs, n->maxs);
if (node->plane_num & 1)
Com_Error(ERR_FATAL, "Odd plane number\n");
n->plane_num = node->plane_num;
n->first_face = d_bsp.num_faces;
if (!node->faces)
c_nofaces++;
else
c_facenodes++;
for (f = node->faces; f; f = f->next)
EmitFace(f);
n->num_faces = d_bsp.num_faces - n->first_face;
// recursively output the other nodes
for (i = 0; i < 2; i++) {
if (node->children[i]->plane_num == PLANENUM_LEAF) {
n->children[i] = -(d_bsp.num_leafs + 1);
EmitLeaf(node->children[i]);
} else {
n->children[i] = d_bsp.num_nodes;
EmitDrawNode_r(node->children[i]);
}
}
return n - d_bsp.nodes;
}
void EmitDrawNodes( node_t *headnode )
{
int i;
BSPModel_t *bm;
int firstleaf;
// qprintf( "--- EmitDrawNodes ---\n" );
if( nummodels == BSP_MAX_MODELS )
Error( "nummodels == BSP_MAX_MODELS" );
bm = &dmodels[nummodels++]; // emit a model
bm->iHeadNode[0] = numnodes;
bm->iFirstFace = firstface;
bm->iNumFaces = numfaces-firstface;
firstface = numfaces;
firstleaf = numleafs;
if( headnode->contents < 0 )
EmitLeaf( headnode );
else
EmitDrawNodes_r( headnode );
bm->iVisLeafs = numleafs - firstleaf;
for( i = 0; i < 3; i++ ) {
bm->fMins[i] = headnode->mins[i] + SIDESPACE + 1; // remove the padding
bm->fMaxs[i] = headnode->maxs[i] - SIDESPACE - 1;
}
}
void EmitDrawNodes_r( node_t *node )
{
int i;
BSPNode_t *n;
if( numnodes == BSP_MAX_NODES )
Error( "numnodes == BSP_MAX_NODES" );
n = &dnodes[numnodes++]; // emit a node
n->iPlaneNum = node->outputplanenum;
n->usFirstFace = node->firstface;
n->usNumFaces = node->numfaces;
VectorCopy( node->mins, n->fMins );
VectorCopy( node->maxs, n->fMaxs );
// recursively output the other nodes
for( i = 0; i < 2; i++ )
{
if( node->children[i]->planenum == PLANENUM_LEAF )
{
n->iChildren[i] = -1;
if( node->children[i]->contents != BSP_CONTENTS_SOLID ) {
int iLeafs = numleafs;
n->iChildren[i] = -(iLeafs + 1);
EmitLeaf( node->children[i] );
}
}
else
{
n->iChildren[i] = numnodes;
EmitDrawNodes_r( node->children[i] );
}
}
}
int EmitDrawNode_r(node_t * node)
{
bspNode_t *n;
int i, n0;
/* check for leafnode */
if(node->planenum == PLANENUM_LEAF)
{
EmitLeaf(node);
return -numBSPLeafs;
}
/* emit a node */
AUTOEXPAND_BY_REALLOC_BSP(Nodes, 1024);
n0 = numBSPNodes;
n = &bspNodes[n0];
numBSPNodes++;
VectorCopy(node->mins, n->mins);
VectorCopy(node->maxs, n->maxs);
if(node->planenum & 1)
Error("WriteDrawNodes_r: odd planenum");
n->planeNum = node->planenum;
//
// recursively output the other nodes
//
for(i = 0; i < 2; i++)
{
if(node->children[i]->planenum == PLANENUM_LEAF)
{
n->children[i] = -(numBSPLeafs + 1);
EmitLeaf(node->children[i]);
}
else
{
n->children[i] = numBSPNodes;
EmitDrawNode_r(node->children[i]);
// n may have become invalid here, so...
n = &bspNodes[n0];
}
}
return n - bspNodes;
}
int EmitDrawNode_r( node_t *node )
{
bspNode_t *n;
int i;
/* check for leafnode */
if( node->planenum == PLANENUM_LEAF )
{
EmitLeaf( node );
return -numBSPLeafs;
}
/* emit a node */
if( numBSPNodes == MAX_MAP_NODES )
Error( "MAX_MAP_NODES" );
n = &bspNodes[ numBSPNodes ];
numBSPNodes++;
VectorCopy (node->mins, n->mins);
VectorCopy (node->maxs, n->maxs);
if (node->planenum & 1)
Error ("WriteDrawNodes_r: odd planenum");
n->planeNum = node->planenum;
//
// recursively output the other nodes
//
for (i=0 ; i<2 ; i++)
{
if (node->children[i]->planenum == PLANENUM_LEAF)
{
n->children[i] = -(numBSPLeafs + 1);
EmitLeaf (node->children[i]);
}
else
{
n->children[i] = numBSPNodes;
EmitDrawNode_r (node->children[i]);
}
}
return n - bspNodes;
}
