// call this routine after the BSP of a Doom wad file is loaded,
// and it will generate all the convex polys for the hardware renderer
void HWR_CreatePlanePolygons(INT32 bspnum)
{
poly_t *rootp;
polyvertex_t *rootpv;
size_t i;
fixed_t rootbbox[4];
DEBPRINT("Creating polygons, please wait...\n");
ls_count = ls_percent = 0; // reset the loading status
CON_Drawer(); //let the user know what we are doing
I_FinishUpdate(); // page flip or blit buffer
HWR_ClearPolys();
// find min/max boundaries of map
//DEBPRINT("Looking for boundaries of map...\n");
M_ClearBox(rootbbox);
for (i = 0;i < numvertexes; i++)
M_AddToBox(rootbbox, vertexes[i].x, vertexes[i].y);
//DEBPRINT("Generating subsector polygons... %d subsectors\n", numsubsectors);
HWR_FreeExtraSubsectors();
// allocate extra data for each subsector present in map
totsubsectors = numsubsectors + NEWSUBSECTORS;
extrasubsectors = calloc(totsubsectors, sizeof (*extrasubsectors));
if (extrasubsectors == NULL)
I_Error("couldn't malloc extrasubsectors totsubsectors %s\n", sizeu1(totsubsectors));
// allocate table for back to front drawing of subsectors
/*gr_drawsubsectors = (INT16 *)malloc(sizeof (*gr_drawsubsectors) * totsubsectors);
if (!gr_drawsubsectors)
I_Error("couldn't malloc gr_drawsubsectors\n");*/
// number of the first new subsector that might be added
addsubsector = numsubsectors;
// construct the initial convex poly that encloses the full map
rootp = HWR_AllocPoly(4);
rootpv = rootp->pts;
rootpv->x = FIXED_TO_FLOAT(rootbbox[BOXLEFT ]);
rootpv->y = FIXED_TO_FLOAT(rootbbox[BOXBOTTOM]); //lr
rootpv++;
rootpv->x = FIXED_TO_FLOAT(rootbbox[BOXLEFT ]);
rootpv->y = FIXED_TO_FLOAT(rootbbox[BOXTOP ]); //ur
rootpv++;
rootpv->x = FIXED_TO_FLOAT(rootbbox[BOXRIGHT ]);
rootpv->y = FIXED_TO_FLOAT(rootbbox[BOXTOP ]); //ul
rootpv++;
rootpv->x = FIXED_TO_FLOAT(rootbbox[BOXRIGHT ]);
rootpv->y = FIXED_TO_FLOAT(rootbbox[BOXBOTTOM]); //ll
rootpv++;
WalkBSPNode(bspnum, rootp, NULL,rootbbox);
i = SolveTProblem();
//DEBPRINT("%d point divides a polygon line\n",i);
AdjustSegs();
//debug debug..
//if (nobackpoly)
// DEBPRINT("no back polygon %u times\n",nobackpoly);
//"(should happen only with the deep water trick)"
//if (skipcut)
// DEBPRINT("%u cuts were skipped because of only one point\n",skipcut);
//DEBPRINT("done: %u total subsector convex polygons\n", totalsubsecpolys);
}
void P_GroupLines(void)
{
line_t **linebuffer;
int i, j, total;
line_t *li;
sector_t *sector;
subsector_t *ss;
seg_t *seg;
fixed_t bbox[4];
int block;
// look up sector number for each subsector
ss = subsectors;
for (i = 0; i < numsubsectors; i++, ss++)
{
seg = &segs[ss->firstline];
ss->sector = seg->sidedef->sector;
}
// count number of lines in each sector
li = lines;
total = 0;
for (i = 0; i < numlines; i++, li++)
{
total++;
li->frontsector->linecount++;
if (li->backsector && li->backsector != li->frontsector)
{
li->backsector->linecount++;
total++;
}
}
// build line tables for each sector
linebuffer = Z_Malloc(total * sizeof(line_t *), PU_LEVEL, 0);
sector = sectors;
for (i = 0; i < numsectors; i++, sector++)
{
M_ClearBox(bbox);
sector->lines = linebuffer;
li = lines;
for (j = 0; j < numlines; j++, li++)
{
if (li->frontsector == sector || li->backsector == sector)
{
*linebuffer++ = li;
M_AddToBox(bbox, li->v1->x, li->v1->y);
M_AddToBox(bbox, li->v2->x, li->v2->y);
}
}
if (linebuffer - sector->lines != sector->linecount)
I_Error("P_GroupLines: miscounted");
// set the degenmobj_t to the middle of the bounding box
sector->soundorg.x = (bbox[BOXRIGHT] + bbox[BOXLEFT]) / 2;
sector->soundorg.y = (bbox[BOXTOP] + bbox[BOXBOTTOM]) / 2;
// adjust bounding box to map blocks
block = (bbox[BOXTOP] - bmaporgy + MAXRADIUS) >> MAPBLOCKSHIFT;
block = block >= bmapheight ? bmapheight - 1 : block;
sector->blockbox[BOXTOP] = block;
block = (bbox[BOXBOTTOM] - bmaporgy - MAXRADIUS) >> MAPBLOCKSHIFT;
block = block < 0 ? 0 : block;
sector->blockbox[BOXBOTTOM] = block;
block = (bbox[BOXRIGHT] - bmaporgx + MAXRADIUS) >> MAPBLOCKSHIFT;
block = block >= bmapwidth ? bmapwidth - 1 : block;
sector->blockbox[BOXRIGHT] = block;
block = (bbox[BOXLEFT] - bmaporgx - MAXRADIUS) >> MAPBLOCKSHIFT;
block = block < 0 ? 0 : block;
sector->blockbox[BOXLEFT] = block;
}
}
// poly : the convex polygon that encloses all child subsectors
static void WalkBSPNode(INT32 bspnum, poly_t *poly, UINT16 *leafnode, fixed_t *bbox)
{
node_t *bsp;
poly_t *backpoly, *frontpoly;
fdivline_t fdivline;
polyvertex_t *pt;
INT32 i;
// Found a subsector?
if (bspnum & NF_SUBSECTOR)
{
if (bspnum == -1)
{
// BP: i think this code is useless and wrong because
// - bspnum==-1 happens only when numsubsectors == 0
// - it can't happens in bsp recursive call since bspnum is a INT32 and children is UINT16
// - the BSP is complet !! (there just can have subsector without segs) (i am not sure of this point)
// do we have a valid polygon ?
if (poly && poly->numpts > 2)
{
DEBPRINT("Adding a new subsector\n");
if (addsubsector == numsubsectors + NEWSUBSECTORS)
I_Error("WalkBSPNode: not enough addsubsectors\n");
else if (addsubsector > 0x7fff)
I_Error("WalkBSPNode: addsubsector > 0x7fff\n");
*leafnode = (UINT16)((UINT16)addsubsector | NF_SUBSECTOR);
extrasubsectors[addsubsector].planepoly = poly;
addsubsector++;
}
//add subsectors without segs here?
//HWR_SubsecPoly(0, NULL);
}
else
{
HWR_SubsecPoly(bspnum&(~NF_SUBSECTOR), poly);
//Hurdler: implement a loading status
if (ls_count-- <= 0)
{
char s[16];
int x, y;
I_OsPolling();
ls_count = numsubsectors/50;
CON_Drawer();
sprintf(s, "%d%%", (++ls_percent)<<1);
x = BASEVIDWIDTH/2;
y = BASEVIDHEIGHT/2;
V_DrawFill(0, 0, vid.width, vid.height, 31); // Black background to match fade in effect
//V_DrawPatchFill(W_CachePatchName("SRB2BACK",PU_CACHE)); // SRB2 background, ehhh too bright.
M_DrawTextBox(x-58, y-8, 13, 1);
V_DrawString(x-50, y, V_YELLOWMAP, "Loading...");
V_DrawString(x+50-V_StringWidth(s), y, V_YELLOWMAP, s);
// Is this really necessary at this point..?
V_DrawCenteredString(BASEVIDWIDTH/2, 40, V_YELLOWMAP, "OPENGL MODE IS INCOMPLETE AND MAY");
V_DrawCenteredString(BASEVIDWIDTH/2, 50, V_YELLOWMAP, "NOT DISPLAY SOME SURFACES.");
V_DrawCenteredString(BASEVIDWIDTH/2, 70, V_YELLOWMAP, "USE AT SONIC'S RISK.");
I_UpdateNoVsync();
}
}
M_ClearBox(bbox);
poly = extrasubsectors[bspnum&~NF_SUBSECTOR].planepoly;
for (i = 0, pt = poly->pts; i < poly->numpts; i++,pt++)
M_AddToBox(bbox, FLOAT_TO_FIXED(pt->x), FLOAT_TO_FIXED(pt->y));
return;
}
bsp = &nodes[bspnum];
SearchDivline(bsp, &fdivline);
SplitPoly(&fdivline, poly, &frontpoly, &backpoly);
poly = NULL;
//debug
if (!backpoly)
nobackpoly++;
// Recursively divide front space.
if (frontpoly)
{
WalkBSPNode(bsp->children[0], frontpoly, &bsp->children[0],bsp->bbox[0]);
// copy child bbox
M_Memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t));
}
else
I_Error("WalkBSPNode: no front poly?");
// Recursively divide back space.
if (backpoly)
{
// Correct back bbox to include floor/ceiling convex polygon
WalkBSPNode(bsp->children[1], backpoly, &bsp->children[1],
bsp->bbox[1]);
// enlarge bbox with seconde child
M_AddToBox(bbox, bsp->bbox[1][BOXLEFT ],
bsp->bbox[1][BOXTOP ]);
M_AddToBox(bbox, bsp->bbox[1][BOXRIGHT ],
bsp->bbox[1][BOXBOTTOM]);
}
}
