void gl_RenderMissingLines()
{
for(int i=firstmissingseg;i<numsegs;i++)
{
seg_t * seg = &segs[i];
// This line has already been processed
if (seg->linedef->validcount==validcount) continue;
// Don't draw lines facing away from the viewer
divline_t dl = { seg->v1->x, seg->v1->y, seg->v2->x-seg->v1->x, seg->v2->y-seg->v1->y };
if (P_PointOnDivlineSide(viewx, viewy, &dl)) continue;
// Unfortunately there is no simple means to exclude lines here so we have
// to draw them all.
sector_t ffakesec, bfakesec;
sector_t * sector = gl_FakeFlat(seg->frontsector, &ffakesec, false);
sector_t * backsector;
if (seg->frontsector == seg->backsector) backsector=sector;
else if (!seg->backsector) backsector=NULL;
else backsector = gl_FakeFlat(seg->backsector, &bfakesec, true);
GLWall wall;
SetupWall.Start(true);
wall.Process(seg, sector, backsector, NULL);
rendered_lines++;
SetupWall.Stop(true);
}
}
void HWDrawInfo::ProcessLowerMinisegs(TArray<seg_t *> &lowersegs)
{
for(unsigned int j=0;j<lowersegs.Size();j++)
{
seg_t * seg=lowersegs[j];
GLWall wall;
wall.ProcessLowerMiniseg(this, seg, seg->Subsector->render_sector, seg->PartnerSeg->Subsector->render_sector);
rendered_lines++;
}
}
void FGLRenderer::ProcessLowerMiniseg(seg_t *seg, sector_t * frontsector, sector_t * backsector)
{
GLWall wall;
wall.ProcessLowerMiniseg(seg, frontsector, backsector);
rendered_lines++;
}
static void AddLine (seg_t *seg,sector_t * sector,subsector_t * polysub)
{
angle_t startAngle, endAngle;
sector_t * backsector = NULL;
sector_t bs;
ClipWall.Clock();
if (GLPortal::mirrorline)
{
// this seg is completely behind the mirror!
if (P_PointOnLineSide(seg->v1->x, seg->v1->y, GLPortal::mirrorline) &&
P_PointOnLineSide(seg->v2->x, seg->v2->y, GLPortal::mirrorline))
{
ClipWall.Unclock();
return;
}
}
startAngle = seg->v2->GetViewAngle();
endAngle = seg->v1->GetViewAngle();
// Back side, i.e. backface culling - read: endAngle >= startAngle!
if (startAngle-endAngle<ANGLE_180 || !seg->linedef)
{
ClipWall.Unclock();
return;
}
if (!clipper.SafeCheckRange(startAngle, endAngle))
{
ClipWall.Unclock();
return;
}
if (!seg->backsector)
{
clipper.SafeAddClipRange(startAngle, endAngle);
}
else if (!polysub) // Two-sided polyobjects never obstruct the view
{
if (sector->sectornum == seg->backsector->sectornum)
{
FTexture * tex = TexMan(seg->sidedef->GetTexture(side_t::mid));
if (!tex || tex->UseType==FTexture::TEX_Null)
{
// nothing to do here!
ClipWall.Unclock();
seg->linedef->validcount=validcount;
return;
}
backsector=sector;
}
else
{
// clipping checks are only needed when the backsector is not the same as the front sector
gl_CheckViewArea(seg->v1, seg->v2, seg->frontsector, seg->backsector);
backsector = gl_FakeFlat(seg->backsector, &bs, true);
if (gl_CheckClip(seg->sidedef, sector, backsector))
{
clipper.SafeAddClipRange(startAngle, endAngle);
}
}
}
else
{
// Backsector for polyobj segs is always the containing sector itself
backsector = sector;
}
seg->linedef->flags |= ML_MAPPED;
ClipWall.Unclock();
if (!gl_render_segs)
{
// rendering per linedef as opposed per seg is significantly more efficient
// so mark the linedef as rendered here and render it completely.
if (seg->linedef->validcount!=validcount) seg->linedef->validcount=validcount;
else return;
}
GLWall wall;
SetupWall.Clock();
wall.Process(seg, sector, backsector, polysub, gl_render_segs);
rendered_lines++;
SetupWall.Unclock();
}
void GLDrawInfo::HandleHackedSubsectors()
{
GLWall wall;
lowershcount=uppershcount=0;
totalssms.Reset();
totalssms.Clock();
viewsubsector = R_PointInSubsector(viewx, viewy);
// Each subsector may only be processed once in this loop!
validcount++;
for(unsigned int i=0;i<SubsectorHacks.Size();i++)
{
subsector_t * sub = SubsectorHacks[i].sub;
if (sub->validcount!=validcount && CheckAnchorFloor(sub))
{
// Now collect everything that is connected with this subsector.
HandledSubsectors.Clear();
inview=false;
lowersegs.Clear();
if (CollectSubsectorsFloor(sub, sub->render_sector))
{
for(unsigned int j=0;j<HandledSubsectors.Size();j++)
{
gl_subsectorrendernode * node = SSR_List.GetNew();
node->sub = HandledSubsectors[j];
AddOtherFloorPlane(sub->render_sector->sectornum, node);
}
if (inview) for(unsigned int j=0;j<lowersegs.Size();j++)
{
seg_t * seg=lowersegs[j];
wall.ProcessLowerMiniseg (seg, seg->Subsector->render_sector, seg->PartnerSeg->Subsector->render_sector);
}
lowershcount+=HandledSubsectors.Size();
}
}
}
// Each subsector may only be processed once in this loop!
validcount++;
for(unsigned int i=0;i<SubsectorHacks.Size();i++)
{
subsector_t * sub = SubsectorHacks[i].sub;
if (sub->validcount!=validcount && CheckAnchorCeiling(sub))
{
// Now collect everything that is connected with this subsector.
HandledSubsectors.Clear();
if (CollectSubsectorsCeiling(sub, sub->render_sector))
{
for(unsigned int j=0;j<HandledSubsectors.Size();j++)
{
gl_subsectorrendernode * node = SSR_List.GetNew();
node->sub = HandledSubsectors[j];
AddOtherCeilingPlane(sub->render_sector->sectornum, node);
}
uppershcount+=HandledSubsectors.Size();
}
}
}
SubsectorHacks.Clear();
totalssms.Unclock();
}
