zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-14 08:31:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

- simplify colormap selection to a single function

Browse source
This commit is contained in:
Magnus Norddahl 2018-12-28 00:55:44 +01:00
parent c0a4ba5e82
commit 4d3d4ea746
13 changed files with 159 additions and 163 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
src/swrenderer/line/r_fogboundary.cpp
View file

@ -54,19 +54,20 @@
namespace swrenderer namespace swrenderer
{ {
void RenderFogBoundary::Render(RenderThread *thread, int x1, int x2, const short *uclip, const short *dclip, int lightlevel, bool foggy, float lightleft, float lightstep, FDynamicColormap *basecolormap) void RenderFogBoundary::Render(RenderThread *thread, int x1, int x2, const short *uclip, const short *dclip, const ProjectedWallLight &wallLight)
{ {
// This is essentially the same as R_MapVisPlane but with an extra step // This is essentially the same as R_MapVisPlane but with an extra step
// to create new horizontal spans whenever the light changes enough that // to create new horizontal spans whenever the light changes enough that
// we need to use a new colormap. // we need to use a new colormap.
int wallshade = LightVisibility::LightLevelToShade(lightlevel, foggy, thread->Viewport.get()); int wallshade = LightVisibility::LightLevelToShade(wallLight.GetLightLevel(), wallLight.GetFoggy(), thread->Viewport.get());
float light = lightleft + lightstep*(x2 - x1 - 1);
int x = x2 - 1; int x = x2 - 1;
int t2 = uclip[x]; int t2 = uclip[x];
int b2 = dclip[x]; int b2 = dclip[x];
float light = wallLight.GetLightPos(x);
int rcolormap = GETPALOOKUP(light, wallshade); int rcolormap = GETPALOOKUP(light, wallshade);
int lcolormap; int lcolormap;
FDynamicColormap *basecolormap = wallLight.GetBaseColormap();
uint8_t *basecolormapdata = basecolormap->Maps; uint8_t *basecolormapdata = basecolormap->Maps;
if (b2 > t2) if (b2 > t2)
@ -75,7 +76,7 @@ namespace swrenderer
} }
drawerargs.SetBaseColormap(basecolormap); drawerargs.SetBaseColormap(basecolormap);
drawerargs.SetLight(light, lightlevel, foggy, thread->Viewport.get()); drawerargs.SetLight(light, wallLight.GetLightLevel(), wallLight.GetFoggy(), thread->Viewport.get());
uint8_t *fake_dc_colormap = basecolormap->Maps + (GETPALOOKUP(light, wallshade) << COLORMAPSHIFT); uint8_t *fake_dc_colormap = basecolormap->Maps + (GETPALOOKUP(light, wallshade) << COLORMAPSHIFT);
@ -86,7 +87,7 @@ namespace swrenderer
const int xr = x + 1; const int xr = x + 1;
int stop; int stop;
light -= lightstep; light -= wallLight.GetLightStep();
lcolormap = GETPALOOKUP(light, wallshade); lcolormap = GETPALOOKUP(light, wallshade);
if (lcolormap != rcolormap) if (lcolormap != rcolormap)
{ {

2
src/swrenderer/line/r_fogboundary.h
View file

@ -31,7 +31,7 @@ namespace swrenderer
class RenderFogBoundary class RenderFogBoundary
{ {
public: public:
void Render(RenderThread *thread, int x1, int x2, const short *uclip, const short *dclip, int lightlevel, bool foggy, float lightleft, float lightstep, FDynamicColormap *basecolormap); void Render(RenderThread *thread, int x1, int x2, const short *uclip, const short *dclip, const ProjectedWallLight &wallLight);
private: private:
void RenderSection(RenderThread *thread, int y, int y2, int x1); void RenderSection(RenderThread *thread, int y, int y2, int x1);

45
src/swrenderer/line/r_line.cpp
View file

@ -71,15 +71,13 @@ namespace swrenderer
Thread = thread; Thread = thread;
} }
void SWRenderLine::Render(seg_t *line, subsector_t *subsector, sector_t *sector, sector_t *fakebacksector, VisiblePlane *linefloorplane, VisiblePlane *lineceilingplane, bool infog, FDynamicColormap *colormap, Fake3DOpaque opaque3dfloor) void SWRenderLine::Render(seg_t *line, subsector_t *subsector, sector_t *sector, sector_t *fakebacksector, VisiblePlane *linefloorplane, VisiblePlane *lineceilingplane, Fake3DOpaque opaque3dfloor)
{ {
mSubsector = subsector; mSubsector = subsector;
mFrontSector = sector; mFrontSector = sector;
mBackSector = fakebacksector; mBackSector = fakebacksector;
mFloorPlane = linefloorplane; mFloorPlane = linefloorplane;
mCeilingPlane = lineceilingplane; mCeilingPlane = lineceilingplane;
mLight.foggy = infog;
mLight.basecolormap = colormap;
mLineSegment = line; mLineSegment = line;
m3DFloor = opaque3dfloor; m3DFloor = opaque3dfloor;
@ -314,7 +312,7 @@ namespace swrenderer
if (!rw_prepped) if (!rw_prepped)
{ {
rw_prepped = true; rw_prepped = true;
SetWallVariables(true); SetWallVariables();
} }
side_t *sidedef = mLineSegment->sidedef; side_t *sidedef = mLineSegment->sidedef;
@ -326,8 +324,7 @@ namespace swrenderer
// 3D floors code abuses the line render code to update plane clipping // 3D floors code abuses the line render code to update plane clipping
// lists but doesn't actually draw anything. // lists but doesn't actually draw anything.
bool onlyUpdatePlaneClip = (m3DFloor.type != Fake3DOpaque::Normal); if (m3DFloor.type == Fake3DOpaque::Normal)
if (!onlyUpdatePlaneClip)
Thread->DrawSegments->Push(draw_segment); Thread->DrawSegments->Push(draw_segment);
draw_segment->CurrentPortalUniq = renderportal->CurrentPortalUniq; draw_segment->CurrentPortalUniq = renderportal->CurrentPortalUniq;
@ -345,7 +342,6 @@ namespace swrenderer
draw_segment->x1 = start; draw_segment->x1 = start;
draw_segment->x2 = stop; draw_segment->x2 = stop;
draw_segment->curline = mLineSegment; draw_segment->curline = mLineSegment;
draw_segment->foggy = mLight.foggy;
draw_segment->SubsectorDepth = Thread->OpaquePass->GetSubsectorDepth(mSubsector->Index()); draw_segment->SubsectorDepth = Thread->OpaquePass->GetSubsectorDepth(mSubsector->Index());
bool markportal = ShouldMarkPortal(); bool markportal = ShouldMarkPortal();
@ -400,7 +396,9 @@ namespace swrenderer
} }
} }
if (!onlyUpdatePlaneClip && r_3dfloors) if (m3DFloor.type == Fake3DOpaque::Normal)
{
if (r_3dfloors)
{ {
if (mBackSector->e && mBackSector->e->XFloor.ffloors.Size()) { if (mBackSector->e && mBackSector->e->XFloor.ffloors.Size()) {
for (i = 0; i < (int)mBackSector->e->XFloor.ffloors.Size(); i++) { for (i = 0; i < (int)mBackSector->e->XFloor.ffloors.Size(); i++) {
@ -422,7 +420,6 @@ namespace swrenderer
} }
} }
if (!onlyUpdatePlaneClip)
// allocate space for masked texture tables, if needed // allocate space for masked texture tables, if needed
// [RH] Don't just allocate the space; fill it in too. // [RH] Don't just allocate the space; fill it in too.
if ((sidedef->GetTexture(side_t::mid).isValid() || draw_segment->Has3DFloorWalls() || IsFogBoundary(mFrontSector, mBackSector)) && if ((sidedef->GetTexture(side_t::mid).isValid() || draw_segment->Has3DFloorWalls() || IsFogBoundary(mFrontSector, mBackSector)) &&
@ -452,8 +449,8 @@ namespace swrenderer
lwal = draw_segment->maskedtexturecol; lwal = draw_segment->maskedtexturecol;
swal = draw_segment->swall; swal = draw_segment->swall;
FTexture *tex = TexMan.GetPalettedTexture(sidedef->GetTexture(side_t::mid), true); FTexture *tex = TexMan.GetPalettedTexture(sidedef->GetTexture(side_t::mid), true);
FSoftwareTexture *pic = tex && tex->isValid()? tex->GetSoftwareTexture() : nullptr; FSoftwareTexture *pic = tex && tex->isValid() ? tex->GetSoftwareTexture() : nullptr;
double yscale = (pic? pic->GetScale().Y : 1.0) * sidedef->GetTextureYScale(side_t::mid); double yscale = (pic ? pic->GetScale().Y : 1.0) * sidedef->GetTextureYScale(side_t::mid);
fixed_t xoffset = FLOAT2FIXED(sidedef->GetTextureXOffset(side_t::mid)); fixed_t xoffset = FLOAT2FIXED(sidedef->GetTextureXOffset(side_t::mid));
if (pic && pic->useWorldPanning()) if (pic && pic->useWorldPanning())
@ -490,28 +487,17 @@ namespace swrenderer
draw_segment->iscalestep = 0; draw_segment->iscalestep = 0;
} }
} }
draw_segment->light = mLight.GetLightPos(start); draw_segment->light = mLight.GetLightPos(start);
draw_segment->lightstep = mLight.GetLightStep(); draw_segment->lightstep = mLight.GetLightStep();
// Masked mMiddlePart.Textures should get the light level from the sector they reference,
// not from the current subsector, which is what the current lightlevel value
// comes from. We make an exeption for polyobjects, however, since their "home"
// sector should be whichever one they move into.
if (mLineSegment->sidedef->Flags & WALLF_POLYOBJ)
{
draw_segment->lightlevel = mLight.lightlevel;
}
else
{
draw_segment->lightlevel = mLineSegment->sidedef->GetLightLevel(mLight.foggy, mLineSegment->frontsector->lightlevel);
}
if (draw_segment->bFogBoundary || draw_segment->maskedtexturecol != nullptr) if (draw_segment->bFogBoundary || draw_segment->maskedtexturecol != nullptr)
{ {
Thread->DrawSegments->PushTranslucent(draw_segment); Thread->DrawSegments->PushTranslucent(draw_segment);
} }
} }
} }
}
ClipSegmentTopBottom(start, stop); ClipSegmentTopBottom(start, stop);
@ -700,7 +686,7 @@ namespace swrenderer
} }
} }
void SWRenderLine::SetWallVariables(bool needlights) void SWRenderLine::SetWallVariables()
{ {
RenderPortal *renderportal = Thread->Portal.get(); RenderPortal *renderportal = Thread->Portal.get();
@ -775,8 +761,13 @@ namespace swrenderer
bool segtextured = ftex != NULL || mTopPart.Texture != NULL || mBottomPart.Texture != NULL; bool segtextured = ftex != NULL || mTopPart.Texture != NULL || mBottomPart.Texture != NULL;
if (m3DFloor.type == Fake3DOpaque::Normal)
{
mLight.SetColormap(mFrontSector, mLineSegment);
}
// calculate light table // calculate light table
if (needlights && (segtextured || (mBackSector && IsFogBoundary(mFrontSector, mBackSector)))) if (segtextured || (mBackSector && IsFogBoundary(mFrontSector, mBackSector)))
{ {
lwallscale = lwallscale =
ftex ? ((midtex? midtex->GetScale().X : 1.0) * sidedef->GetTextureXScale(side_t::mid)) : ftex ? ((midtex? midtex->GetScale().X : 1.0) * sidedef->GetTextureXScale(side_t::mid)) :
@ -786,7 +777,7 @@ namespace swrenderer
walltexcoords.Project(Thread->Viewport.get(), sidedef->TexelLength * lwallscale, WallC.sx1, WallC.sx2, WallT); walltexcoords.Project(Thread->Viewport.get(), sidedef->TexelLength * lwallscale, WallC.sx1, WallC.sx2, WallT);
mLight.SetLightLeft(Thread, mLineSegment, mFrontSector, WallC); mLight.SetLightLeft(Thread, WallC);
} }
} }

4
src/swrenderer/line/r_line.h
View file

@ -72,13 +72,13 @@ namespace swrenderer
{ {
public: public:
SWRenderLine(RenderThread *thread); SWRenderLine(RenderThread *thread);
void Render(seg_t *line, subsector_t *subsector, sector_t *sector, sector_t *fakebacksector, VisiblePlane *floorplane, VisiblePlane *ceilingplane, bool foggy, FDynamicColormap *basecolormap, Fake3DOpaque fake3DOpaque); void Render(seg_t *line, subsector_t *subsector, sector_t *sector, sector_t *fakebacksector, VisiblePlane *floorplane, VisiblePlane *ceilingplane, Fake3DOpaque fake3DOpaque);
RenderThread *Thread = nullptr; RenderThread *Thread = nullptr;
private: private:
bool RenderWallSegment(int x1, int x2) override; bool RenderWallSegment(int x1, int x2) override;
void SetWallVariables(bool needlights); void SetWallVariables();
void SetTopTexture(); void SetTopTexture();
void SetMiddleTexture(); void SetMiddleTexture();
void SetBottomTexture(); void SetBottomTexture();

58
src/swrenderer/line/r_renderdrawsegment.cpp
View file

@ -80,9 +80,7 @@ namespace swrenderer
sector_t tempsec; sector_t tempsec;
const sector_t *sec = Thread->OpaquePass->FakeFlat(frontsector, &tempsec, nullptr, nullptr, nullptr, 0, 0, 0, 0); const sector_t *sec = Thread->OpaquePass->FakeFlat(frontsector, &tempsec, nullptr, nullptr, nullptr, 0, 0, 0, 0);
mLight.basecolormap = GetColorTable(sec->Colormap, sec->SpecialColors[sector_t::walltop]); // [RH] Set basecolormap mLight.SetColormap(sec, curline);
mLight.foggy = ds->foggy;
mLight.lightlevel = ds->lightlevel;
mLight.SetLightLeft(ds->light, ds->lightstep, ds->x1); mLight.SetLightLeft(ds->light, ds->lightstep, ds->x1);
Clip3DFloors *clip3d = Thread->Clip3D.get(); Clip3DFloors *clip3d = Thread->Clip3D.get();
@ -92,10 +90,7 @@ namespace swrenderer
{ {
if (clipTop <= frontsector->e->XFloor.lightlist[i].plane.Zat0()) if (clipTop <= frontsector->e->XFloor.lightlist[i].plane.Zat0())
{ {
lightlist_t *lit = &frontsector->e->XFloor.lightlist[i]; mLight.SetColormap(frontsector, curline, &frontsector->e->XFloor.lightlist[i]);
mLight.basecolormap = GetColorTable(lit->extra_colormap, frontsector->SpecialColors[sector_t::walltop]);
mLight.foggy = (level.fadeto || mLight.basecolormap->Fade || (level.flags & LEVEL_HASFADETABLE)); // [RH] set foggy flag
mLight.lightlevel = curline->sidedef->GetLightLevel(ds->foggy, *lit->p_lightlevel, lit->lightsource != nullptr);
break; break;
} }
} }
@ -105,7 +100,7 @@ namespace swrenderer
SpriteDrawerArgs columndrawerargs; SpriteDrawerArgs columndrawerargs;
ColormapLight cmlight; ColormapLight cmlight;
cmlight.SetColormap(Thread, MINZ, mLight.lightlevel, mLight.foggy, mLight.basecolormap, false, false, false, false, false); cmlight.SetColormap(Thread, MINZ, mLight.GetLightLevel(), mLight.GetFoggy(), mLight.GetBaseColormap(), false, false, false, false, false);
bool visible = columndrawerargs.SetStyle(viewport, LegacyRenderStyles[additive ? STYLE_Add : STYLE_Translucent], alpha, 0, 0, cmlight); bool visible = columndrawerargs.SetStyle(viewport, LegacyRenderStyles[additive ? STYLE_Add : STYLE_Translucent], alpha, 0, 0, cmlight);
if (!visible && !ds->bFogBoundary && !ds->Has3DFloorWalls()) if (!visible && !ds->bFogBoundary && !ds->Has3DFloorWalls())
{ {
@ -121,7 +116,7 @@ namespace swrenderer
const short *mceilingclip = ds->sprtopclip - ds->x1; const short *mceilingclip = ds->sprtopclip - ds->x1;
RenderFogBoundary renderfog; RenderFogBoundary renderfog;
renderfog.Render(Thread, x1, x2, mceilingclip, mfloorclip, mLight.lightlevel, ds->foggy, mLight.GetLightPos(x1), mLight.GetLightStep(), mLight.basecolormap); renderfog.Render(Thread, x1, x2, mceilingclip, mfloorclip, mLight);
if (ds->maskedtexturecol == nullptr) if (ds->maskedtexturecol == nullptr)
renderwall = false; renderwall = false;
@ -319,7 +314,7 @@ namespace swrenderer
for (int x = x1; x < x2; ++x) for (int x = x1; x < x2; ++x)
{ {
if (needslight) if (needslight)
columndrawerargs.SetLight(lightpos, mLight.lightlevel, mLight.foggy, Thread->Viewport.get()); columndrawerargs.SetLight(lightpos, mLight.GetLightLevel(), mLight.GetFoggy(), Thread->Viewport.get());
fixed_t iscale = xs_Fix<16>::ToFix(MaskedSWall[x] * MaskedScaleY); fixed_t iscale = xs_Fix<16>::ToFix(MaskedSWall[x] * MaskedScaleY);
double sprtopscreen; double sprtopscreen;
@ -693,9 +688,11 @@ namespace swrenderer
} }
rw_pic = rw_tex && rw_tex->isValid() ? rw_tex->GetSoftwareTexture() : nullptr; rw_pic = rw_tex && rw_tex->isValid() ? rw_tex->GetSoftwareTexture() : nullptr;
} }
if (rw_pic && !swimmable_found)
{
// correct colors now // correct colors now
mLight.basecolormap = nullptr; lightlist_t *lit = nullptr;
mLight.lightlevel = ds->lightlevel;
CameraLight *cameraLight = CameraLight::Instance(); CameraLight *cameraLight = CameraLight::Instance();
if (cameraLight->FixedLightLevel() < 0) if (cameraLight->FixedLightLevel() < 0)
{ {
@ -705,10 +702,7 @@ namespace swrenderer
{ {
if (clipTop <= backsector->e->XFloor.lightlist[j].plane.Zat0()) if (clipTop <= backsector->e->XFloor.lightlist[j].plane.Zat0())
{ {
lightlist_t *lit = &backsector->e->XFloor.lightlist[j]; lit = &backsector->e->XFloor.lightlist[j];
mLight.basecolormap = GetColorTable(lit->extra_colormap, frontsector->SpecialColors[sector_t::walltop]);
mLight.foggy = (level.fadeto || mLight.basecolormap->Fade || (level.flags & LEVEL_HASFADETABLE)); // [RH] set foggy flag
mLight.lightlevel = curline->sidedef->GetLightLevel(ds->foggy, *lit->p_lightlevel, lit->lightsource != nullptr);
break; break;
} }
} }
@ -719,19 +713,16 @@ namespace swrenderer
{ {
if (clipTop <= frontsector->e->XFloor.lightlist[j].plane.Zat0()) if (clipTop <= frontsector->e->XFloor.lightlist[j].plane.Zat0())
{ {
lightlist_t *lit = &frontsector->e->XFloor.lightlist[j]; lit = &frontsector->e->XFloor.lightlist[j];
mLight.basecolormap = GetColorTable(lit->extra_colormap, frontsector->SpecialColors[sector_t::walltop]);
mLight.foggy = (level.fadeto || mLight.basecolormap->Fade || (level.flags & LEVEL_HASFADETABLE)); // [RH] set foggy flag
mLight.lightlevel = curline->sidedef->GetLightLevel(ds->foggy, *lit->p_lightlevel, lit->lightsource != nullptr);
break; break;
} }
} }
} }
} }
if (mLight.basecolormap == nullptr) mLight.basecolormap = GetColorTable(frontsector->Colormap, frontsector->SpecialColors[sector_t::walltop]);
if (rw_pic && !swimmable_found) //mLight.lightlevel = ds->lightlevel;
{ mLight.SetColormap(frontsector, curline, lit);
RenderFakeWall(ds, x1, x2, fover ? fover : rover, clipTop, clipBottom, rw_pic); RenderFakeWall(ds, x1, x2, fover ? fover : rover, clipTop, clipBottom, rw_pic);
} }
break; break;
@ -880,9 +871,11 @@ namespace swrenderer
} }
rw_pic = rw_tex && rw_tex->isValid() ? rw_tex->GetSoftwareTexture() : nullptr; rw_pic = rw_tex && rw_tex->isValid() ? rw_tex->GetSoftwareTexture() : nullptr;
} }
if (rw_pic && !swimmable_found)
{
// correct colors now // correct colors now
mLight.basecolormap = nullptr; lightlist_t *lit = nullptr;
mLight.lightlevel = ds->lightlevel;
CameraLight *cameraLight = CameraLight::Instance(); CameraLight *cameraLight = CameraLight::Instance();
if (cameraLight->FixedLightLevel() < 0) if (cameraLight->FixedLightLevel() < 0)
{ {
@ -892,10 +885,7 @@ namespace swrenderer
{ {
if (clipTop <= backsector->e->XFloor.lightlist[j].plane.Zat0()) if (clipTop <= backsector->e->XFloor.lightlist[j].plane.Zat0())
{ {
lightlist_t *lit = &backsector->e->XFloor.lightlist[j]; lit = &backsector->e->XFloor.lightlist[j];
mLight.basecolormap = GetColorTable(lit->extra_colormap, frontsector->SpecialColors[sector_t::walltop]);
mLight.foggy = (level.fadeto || mLight.basecolormap->Fade || (level.flags & LEVEL_HASFADETABLE)); // [RH] set foggy flag
mLight.lightlevel = curline->sidedef->GetLightLevel(ds->foggy, *lit->p_lightlevel, lit->lightsource != nullptr);
break; break;
} }
} }
@ -906,19 +896,15 @@ namespace swrenderer
{ {
if (clipTop <= frontsector->e->XFloor.lightlist[j].plane.Zat0()) if (clipTop <= frontsector->e->XFloor.lightlist[j].plane.Zat0())
{ {
lightlist_t *lit = &frontsector->e->XFloor.lightlist[j]; lit = &frontsector->e->XFloor.lightlist[j];
mLight.basecolormap = GetColorTable(lit->extra_colormap, frontsector->SpecialColors[sector_t::walltop]);
mLight.foggy = (level.fadeto || mLight.basecolormap->Fade || (level.flags & LEVEL_HASFADETABLE)); // [RH] set foggy flag
mLight.lightlevel = curline->sidedef->GetLightLevel(ds->foggy, *lit->p_lightlevel, lit->lightsource != nullptr);
break; break;
} }
} }
} }
} }
if (mLight.basecolormap == nullptr) mLight.basecolormap = GetColorTable(frontsector->Colormap, frontsector->SpecialColors[sector_t::walltop]); //mLight.lightlevel = ds->lightlevel;
mLight.SetColormap(frontsector, curline, lit);
if (rw_pic && !swimmable_found)
{
RenderFakeWall(ds, x1, x2, fover ? fover : rover, clipTop, clipBottom, rw_pic); RenderFakeWall(ds, x1, x2, fover ? fover : rover, clipTop, clipBottom, rw_pic);
} }
break; break;

10
src/swrenderer/line/r_walldraw.cpp
View file

@ -349,11 +349,11 @@ namespace swrenderer
// Textures that aren't masked can use the faster opaque drawer // Textures that aren't masked can use the faster opaque drawer
if (!rw_pic->GetTexture()->isMasked() && mask && alpha >= OPAQUE && !additive) if (!rw_pic->GetTexture()->isMasked() && mask && alpha >= OPAQUE && !additive)
{ {
drawerargs.SetStyle(true, false, OPAQUE, mLight.basecolormap); drawerargs.SetStyle(true, false, OPAQUE, mLight.GetBaseColormap());
} }
else else
{ {
drawerargs.SetStyle(mask, additive, alpha, mLight.basecolormap); drawerargs.SetStyle(mask, additive, alpha, mLight.GetBaseColormap());
} }
CameraLight *cameraLight = CameraLight::Instance(); CameraLight *cameraLight = CameraLight::Instance();
@ -377,7 +377,7 @@ namespace swrenderer
continue; continue;
if (!fixed) if (!fixed)
drawerargs.SetLight(curlight, mLight.lightlevel, mLight.foggy, Thread->Viewport.get()); drawerargs.SetLight(curlight, mLight.GetLightLevel(), mLight.GetFoggy(), Thread->Viewport.get());
if (x + 1 < x2) xmagnitude = fabs(FIXED2DBL(lwal[x + 1]) - FIXED2DBL(lwal[x])); if (x + 1 < x2) xmagnitude = fabs(FIXED2DBL(lwal[x + 1]) - FIXED2DBL(lwal[x]));
@ -423,9 +423,7 @@ namespace swrenderer
down = (down == most1.ScreenY) ? most2.ScreenY : most1.ScreenY; down = (down == most1.ScreenY) ? most2.ScreenY : most1.ScreenY;
} }
lightlist_t *lit = &frontsector->e->XFloor.lightlist[i]; mLight.SetColormap(frontsector, curline, &frontsector->e->XFloor.lightlist[i]);
mLight.basecolormap = GetColorTable(lit->extra_colormap, frontsector->SpecialColors[sector_t::walltop]);
mLight.lightlevel = curline->sidedef->GetLightLevel(mLight.foggy, *lit->p_lightlevel, lit->lightsource != NULL);
} }
ProcessNormalWall(up, dwal, texturemid, swal, lwal); ProcessNormalWall(up, dwal, texturemid, swal, lwal);

23
src/swrenderer/line/r_wallsetup.cpp
View file

@ -244,14 +244,13 @@ namespace swrenderer
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
void ProjectedWallLight::SetLightLeft(RenderThread *thread, seg_t *lineseg, sector_t *frontsector, const FWallCoords &wallc) void ProjectedWallLight::SetLightLeft(RenderThread *thread, const FWallCoords &wallc)
{ {
x1 = wallc.sx1; x1 = wallc.sx1;
CameraLight *cameraLight = CameraLight::Instance(); CameraLight *cameraLight = CameraLight::Instance();
if (cameraLight->FixedColormap() == nullptr && cameraLight->FixedLightLevel() < 0) if (cameraLight->FixedColormap() == nullptr && cameraLight->FixedLightLevel() < 0)
{ {
lightlevel = lineseg->sidedef->GetLightLevel(foggy, frontsector->lightlevel);
lightleft = float(thread->Light->WallVis(wallc.sz1, foggy)); lightleft = float(thread->Light->WallVis(wallc.sz1, foggy));
lightstep = float((thread->Light->WallVis(wallc.sz2, foggy) - lightleft) / (wallc.sx2 - wallc.sx1)); lightstep = float((thread->Light->WallVis(wallc.sz2, foggy) - lightleft) / (wallc.sx2 - wallc.sx1));
} }
@ -261,4 +260,24 @@ namespace swrenderer
lightstep = 0; lightstep = 0;
} }
} }
void ProjectedWallLight::SetColormap(const sector_t *frontsector, seg_t *lineseg, lightlist_t *lit)
{
if (!lit)
{
basecolormap = GetColorTable(frontsector->Colormap, frontsector->SpecialColors[sector_t::walltop]);
foggy = level.fadeto || frontsector->Colormap.FadeColor || (level.flags & LEVEL_HASFADETABLE);
if (!(lineseg->sidedef->Flags & WALLF_POLYOBJ))
lightlevel = lineseg->sidedef->GetLightLevel(foggy, frontsector->lightlevel);
else
lightlevel = frontsector->GetLightLevel();
}
else
{
basecolormap = GetColorTable(lit->extra_colormap, frontsector->SpecialColors[sector_t::walltop]);
foggy = level.fadeto || basecolormap->Fade || (level.flags & LEVEL_HASFADETABLE);
lightlevel = lineseg->sidedef->GetLightLevel(foggy, *lit->p_lightlevel, lit->lightsource != nullptr);
}
}
} }

14
src/swrenderer/line/r_wallsetup.h
View file

@ -60,17 +60,23 @@ namespace swrenderer
class ProjectedWallLight class ProjectedWallLight
{ {
public: public:
int lightlevel; int GetLightLevel() const { return lightlevel; }
bool foggy; bool GetFoggy() const { return foggy; }
FDynamicColormap *basecolormap; FDynamicColormap *GetBaseColormap() const { return basecolormap; }
float GetLightPos(int x) const { return lightleft + lightstep * (x - x1); } float GetLightPos(int x) const { return lightleft + lightstep * (x - x1); }
float GetLightStep() const { return lightstep; } float GetLightStep() const { return lightstep; }
void SetColormap(const sector_t *frontsector, seg_t *lineseg, lightlist_t *lit = nullptr);
void SetLightLeft(float left, float step, int startx) { lightleft = left; lightstep = step; x1 = startx; } void SetLightLeft(float left, float step, int startx) { lightleft = left; lightstep = step; x1 = startx; }
void SetLightLeft(RenderThread *thread, seg_t *lineseg, sector_t *frontsector, const FWallCoords &wallc); void SetLightLeft(RenderThread *thread, const FWallCoords &wallc);
private: private:
int lightlevel;
bool foggy;
FDynamicColormap *basecolormap;
int x1; int x1;
float lightleft; float lightleft;
float lightstep; float lightstep;

18
src/swrenderer/scene/r_opaque_pass.cpp
View file

@ -451,7 +451,7 @@ namespace swrenderer
} }
// kg3D - add fake segs, never rendered // kg3D - add fake segs, never rendered
void RenderOpaquePass::FakeDrawLoop(subsector_t *sub, sector_t *frontsector, VisiblePlane *floorplane, VisiblePlane *ceilingplane, bool foggy, FDynamicColormap *basecolormap, Fake3DOpaque opaque3dfloor) void RenderOpaquePass::FakeDrawLoop(subsector_t *sub, sector_t *frontsector, VisiblePlane *floorplane, VisiblePlane *ceilingplane, Fake3DOpaque opaque3dfloor)
{ {
int count; int count;
seg_t* line; seg_t* line;
@ -463,7 +463,7 @@ namespace swrenderer
{ {
if ((line->sidedef) && !(line->sidedef->Flags & WALLF_POLYOBJ)) if ((line->sidedef) && !(line->sidedef->Flags & WALLF_POLYOBJ))
{ {
renderline.Render(line, InSubsector, frontsector, nullptr, floorplane, ceilingplane, foggy, basecolormap, opaque3dfloor); renderline.Render(line, InSubsector, frontsector, nullptr, floorplane, ceilingplane, opaque3dfloor);
} }
line++; line++;
} }
@ -622,8 +622,6 @@ namespace swrenderer
DVector2 viewpointPos = Thread->Viewport->viewpoint.Pos.XY(); DVector2 viewpointPos = Thread->Viewport->viewpoint.Pos.XY();
basecolormap = GetColorTable(frontsector->Colormap, frontsector->SpecialColors[sector_t::walltop]);
seg_t *line = sub->firstline; seg_t *line = sub->firstline;
int count = sub->numlines; int count = sub->numlines;
while (count--) while (count--)
@ -637,8 +635,8 @@ namespace swrenderer
} }
else if (!outersubsector || line->sidedef == nullptr || !(line->sidedef->Flags & WALLF_POLYOBJ)) else if (!outersubsector || line->sidedef == nullptr || !(line->sidedef->Flags & WALLF_POLYOBJ))
{ {
Add3DFloorLine(line, frontsector, basecolormap, foggy); Add3DFloorLine(line, frontsector);
renderline.Render(line, InSubsector, frontsector, nullptr, floorplane, ceilingplane, foggy, basecolormap, Fake3DOpaque::Normal); // now real renderline.Render(line, InSubsector, frontsector, nullptr, floorplane, ceilingplane, Fake3DOpaque::Normal); // now real
} }
line++; line++;
} }
@ -648,7 +646,7 @@ namespace swrenderer
} }
} }
void RenderOpaquePass::Add3DFloorLine(seg_t *line, sector_t *frontsector, FDynamicColormap *basecolormap, bool foggy) void RenderOpaquePass::Add3DFloorLine(seg_t *line, sector_t *frontsector)
{ {
// kg3D - fake planes bounding calculation // kg3D - fake planes bounding calculation
if (r_3dfloors && line->backsector && frontsector->e && line->backsector->e->XFloor.ffloors.Size()) if (r_3dfloors && line->backsector && frontsector->e && line->backsector->e->XFloor.ffloors.Size())
@ -669,7 +667,7 @@ namespace swrenderer
clip3d->fakeFloor->validcount = validcount; clip3d->fakeFloor->validcount = validcount;
clip3d->NewClip(); clip3d->NewClip();
} }
renderline.Render(line, InSubsector, frontsector, &tempsec, nullptr, nullptr, foggy, basecolormap, opaque3dfloor); // fake renderline.Render(line, InSubsector, frontsector, &tempsec, nullptr, nullptr, opaque3dfloor); // fake
} }
clip3d->fakeFloor = nullptr; clip3d->fakeFloor = nullptr;
} }
@ -744,7 +742,7 @@ namespace swrenderer
floorplane3d->AddLights(Thread, sub->section->lighthead); floorplane3d->AddLights(Thread, sub->section->lighthead);
FakeDrawLoop(sub, &tempsec, floorplane3d, nullptr, foggy, basecolormap, Fake3DOpaque::FakeFloor); FakeDrawLoop(sub, &tempsec, floorplane3d, nullptr, Fake3DOpaque::FakeFloor);
} }
} }
// and now ceilings // and now ceilings
@ -812,7 +810,7 @@ namespace swrenderer
ceilingplane3d->AddLights(Thread, sub->section->lighthead); ceilingplane3d->AddLights(Thread, sub->section->lighthead);
FakeDrawLoop(sub, &tempsec, nullptr, ceilingplane3d, foggy, basecolormap, Fake3DOpaque::FakeCeiling); FakeDrawLoop(sub, &tempsec, nullptr, ceilingplane3d, Fake3DOpaque::FakeCeiling);
} }
} }
clip3d->fakeFloor = nullptr; clip3d->fakeFloor = nullptr;

4
src/swrenderer/scene/r_opaque_pass.h
View file

@ -86,8 +86,8 @@ namespace swrenderer
void AddPolyobjs(subsector_t *sub); void AddPolyobjs(subsector_t *sub);
void Add3DFloorPlanes(subsector_t *sub, sector_t *frontsector, FDynamicColormap *basecolormap, bool foggy, int adjusted_ceilinglightlevel, int adjusted_floorlightlevel); void Add3DFloorPlanes(subsector_t *sub, sector_t *frontsector, FDynamicColormap *basecolormap, bool foggy, int adjusted_ceilinglightlevel, int adjusted_floorlightlevel);
void FakeDrawLoop(subsector_t *sub, sector_t *frontsector, VisiblePlane *floorplane, VisiblePlane *ceilingplane, bool foggy, FDynamicColormap *basecolormap, Fake3DOpaque opaque3dfloor); void FakeDrawLoop(subsector_t *sub, sector_t *frontsector, VisiblePlane *floorplane, VisiblePlane *ceilingplane, Fake3DOpaque opaque3dfloor);
void Add3DFloorLine(seg_t *line, sector_t *frontsector, FDynamicColormap *basecolormap, bool foggy); void Add3DFloorLine(seg_t *line, sector_t *frontsector);
void AddSprites(sector_t *sec, int lightlevel, WaterFakeSide fakeside, bool foggy, FDynamicColormap *basecolormap); void AddSprites(sector_t *sec, int lightlevel, WaterFakeSide fakeside, bool foggy, FDynamicColormap *basecolormap);
bool IsPotentiallyVisible(AActor *thing); bool IsPotentiallyVisible(AActor *thing);

1
src/swrenderer/scene/r_portal.cpp
View file

@ -219,7 +219,6 @@ namespace swrenderer
draw_segment->swall = nullptr; draw_segment->swall = nullptr;
draw_segment->bFogBoundary = false; draw_segment->bFogBoundary = false;
draw_segment->curline = nullptr; draw_segment->curline = nullptr;
draw_segment->foggy = false;
memcpy(draw_segment->sprbottomclip, floorclip + pl->left, (pl->right - pl->left) * sizeof(short)); memcpy(draw_segment->sprbottomclip, floorclip + pl->left, (pl->right - pl->left) * sizeof(short));
memcpy(draw_segment->sprtopclip, ceilingclip + pl->left, (pl->right - pl->left) * sizeof(short)); memcpy(draw_segment->sprtopclip, ceilingclip + pl->left, (pl->right - pl->left) * sizeof(short));
drawseglist->Push(draw_segment); drawseglist->Push(draw_segment);

2
src/swrenderer/segments/r_drawsegment.h
View file

@ -38,8 +38,6 @@ namespace swrenderer
float yscale; float yscale;
uint8_t silhouette = 0; // 0=none, 1=bottom, 2=top, 3=both uint8_t silhouette = 0; // 0=none, 1=bottom, 2=top, 3=both
bool bFogBoundary = false; bool bFogBoundary = false;
int lightlevel = 0;
bool foggy = false;
// Pointers to lists for sprite clipping, all three adjusted so [x1] is first value. // Pointers to lists for sprite clipping, all three adjusted so [x1] is first value.
short *sprtopclip = nullptr; short *sprtopclip = nullptr;

6
src/swrenderer/things/r_decal.cpp
View file

@ -256,7 +256,7 @@ namespace swrenderer
} }
// Prepare lighting // Prepare lighting
usecolormap = light.basecolormap; usecolormap = light.GetBaseColormap();
// Decals that are added to the scene must fade to black. // Decals that are added to the scene must fade to black.
if (decal->RenderStyle == LegacyRenderStyles[STYLE_Add] && usecolormap->Fade != 0) if (decal->RenderStyle == LegacyRenderStyles[STYLE_Add] && usecolormap->Fade != 0)
@ -287,7 +287,7 @@ namespace swrenderer
int x = x1; int x = x1;
ColormapLight cmlight; ColormapLight cmlight;
cmlight.SetColormap(thread, MINZ, light.lightlevel, light.foggy, usecolormap, decal->RenderFlags & RF_FULLBRIGHT, false, false, false, false); cmlight.SetColormap(thread, MINZ, light.GetLightLevel(), light.GetFoggy(), usecolormap, decal->RenderFlags & RF_FULLBRIGHT, false, false, false, false);
SpriteDrawerArgs drawerargs; SpriteDrawerArgs drawerargs;
bool visible = drawerargs.SetStyle(thread->Viewport.get(), decal->RenderStyle, (float)decal->Alpha, decal->Translation, decal->AlphaColor, cmlight); bool visible = drawerargs.SetStyle(thread->Viewport.get(), decal->RenderStyle, (float)decal->Alpha, decal->Translation, decal->AlphaColor, cmlight);
@ -300,7 +300,7 @@ namespace swrenderer
{ {
if (calclighting) if (calclighting)
{ // calculate lighting { // calculate lighting
drawerargs.SetLight(lightpos, light.lightlevel, light.foggy, thread->Viewport.get()); drawerargs.SetLight(lightpos, light.GetLightLevel(), light.GetFoggy(), thread->Viewport.get());
} }
DrawColumn(thread, drawerargs, x, WallSpriteTile, walltexcoords, texturemid, maskedScaleY, sprflipvert, mfloorclip, mceilingclip, decal->RenderStyle); DrawColumn(thread, drawerargs, x, WallSpriteTile, walltexcoords, texturemid, maskedScaleY, sprflipvert, mfloorclip, mceilingclip, decal->RenderStyle);
lightpos += light.GetLightStep(); lightpos += light.GetLightStep();