zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-28 06:53:40 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Put more floor/ceiling properties in sector_t into a substructure and

Browse source 
added wrapper functions.


SVN r1174 (trunk)
This commit is contained in:
Christoph Oelckers 2008-08-16 20:19:35 +00:00
parent fcdef6a0de
commit bc5d0c882b
29 changed files with 271 additions and 246 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
docs/rh-log.txt
View file

@ -1,4 +1,6 @@
August 16, 2008 (Changes by Graf Zahl)
- Put more floor/ceiling properties in sector_t into a substructure and
added wrapper functions.
- Fixed: A_Explode wants the distance parameter as an int, not a fixed_t.
- some minor DECORATE fixes.

20
src/dsectoreffect.cpp
View file

@ -186,7 +186,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
}
else
{
m_Sector->floortexz += move;
m_Sector->ChangePlaneTexZ(sector_t::floor, move);
m_Sector->AdjustFloorClip ();
}
return pastdest;
@ -207,7 +207,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
}
else
{
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
}
}
@ -244,7 +244,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
}
else
{
m_Sector->floortexz += move;
m_Sector->ChangePlaneTexZ(sector_t::floor, move);
m_Sector->AdjustFloorClip ();
}
return pastdest;
@ -261,7 +261,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
{
if (crush >= 0 && !hexencrush)
{
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
return crushed;
}
@ -270,7 +270,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
MoveAttached(crush, -speed, 0, false);
return crushed;
}
m_Sector->floortexz += m_Sector->floorplane.HeightDiff (lastpos);
m_Sector->ChangePlaneTexZ(sector_t::floortexz, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
}
break;
@ -311,7 +311,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
}
else
{
m_Sector->ceilingtexz += move;
m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
}
return pastdest;
}
@ -327,7 +327,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
{
if (crush >= 0 && !hexencrush)
{
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
return crushed;
}
m_Sector->ceilingplane.d = lastpos;
@ -335,7 +335,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
MoveAttached(crush, speed, 1, false);
return crushed;
}
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
}
break;
@ -359,7 +359,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
}
else
{
m_Sector->ceilingtexz += move;
m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
}
return pastdest;
}
@ -377,7 +377,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush,
MoveAttached(crush, -speed, 1, false);
return crushed;
}
m_Sector->ceilingtexz += m_Sector->ceilingplane.HeightDiff (lastpos);
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
}
break;
}

24
src/g_shared/a_decals.cpp
View file

@ -245,27 +245,27 @@ FTextureID DBaseDecal::StickToWall (side_t *wall, fixed_t x, fixed_t y)
{
RenderFlags |= RF_RELMID;
if (line->flags & ML_DONTPEGBOTTOM)
Z -= front->floortexz;
Z -= front->GetPlaneTexZ(sector_t::floor);
else
Z -= front->ceilingtexz;
Z -= front->GetPlaneTexZ(sector_t::ceiling);
tex = wall->GetTexture(side_t::mid);
}
else if (back->floorplane.ZatPoint (x, y) >= Z)
{
RenderFlags |= RF_RELLOWER|RF_CLIPLOWER;
if (line->flags & ML_DONTPEGBOTTOM)
Z -= front->ceilingtexz;
Z -= front->GetPlaneTexZ(sector_t::ceiling);
else
Z -= back->floortexz;
Z -= back->GetPlaneTexZ(sector_t::floor);
tex = wall->GetTexture(side_t::bottom);
}
else
{
RenderFlags |= RF_RELUPPER|RF_CLIPUPPER;
if (line->flags & ML_DONTPEGTOP)
Z -= front->ceilingtexz;
Z -= front->GetPlaneTexZ(sector_t::ceiling);
else
Z -= back->ceilingtexz;
Z -= back->GetPlaneTexZ(sector_t::ceiling);
tex = wall->GetTexture(side_t::top);
}
@ -301,29 +301,29 @@ fixed_t DBaseDecal::GetRealZ (const side_t *wall) const
case RF_RELUPPER:
if (curline->linedef->flags & ML_DONTPEGTOP)
{
return Z + front->ceilingtexz;
return Z + front->GetPlaneTexZ(sector_t::ceiling);
}
else
{
return Z + back->ceilingtexz;
return Z + back->GetPlaneTexZ(sector_t::ceiling);
}
case RF_RELLOWER:
if (curline->linedef->flags & ML_DONTPEGBOTTOM)
{
return Z + front->ceilingtexz;
return Z + front->GetPlaneTexZ(sector_t::ceiling);
}
else
{
return Z + back->floortexz;
return Z + back->GetPlaneTexZ(sector_t::floor);
}
case RF_RELMID:
if (curline->linedef->flags & ML_DONTPEGBOTTOM)
{
return Z + front->floortexz;
return Z + front->GetPlaneTexZ(sector_t::floor);
}
else
{
return Z + front->ceilingtexz;
return Z + front->GetPlaneTexZ(sector_t::ceiling);
}
}
}

2
src/g_shared/a_lightning.cpp
View file

@ -118,7 +118,7 @@ void DLightningThinker::LightningFlash ()
{
// allow combination of the lightning sector specials with bit masks
int special = (tempSec->special&0xff);
if (tempSec->ceilingpic == skyflatnum
if (tempSec->GetTexture(sector_t::ceiling) == skyflatnum
|| special == Light_IndoorLightning1
|| special == Light_IndoorLightning2
|| special == Light_OutdoorLightning)

4
src/p_3dmidtex.cpp
View file

@ -231,14 +231,14 @@ bool P_GetMidTexturePosition(const line_t *line, int sideno, fixed_t *ptextop, f
if(line->flags & ML_DONTPEGBOTTOM)
{
*ptexbot = y_offset +
MAX<fixed_t>(line->frontsector->floortexz, line->backsector->floortexz);
MAX<fixed_t>(line->frontsector->GetPlaneTexZ(sector_t::floor), line->backsector->GetPlaneTexZ(sector_t::floor));
*ptextop = *ptexbot + textureheight;
}
else
{
*ptextop = y_offset +
MIN<fixed_t>(line->frontsector->ceilingtexz, line->backsector->ceilingtexz);
MIN<fixed_t>(line->frontsector->GetPlaneTexZ(sector_t::ceiling), line->backsector->GetPlaneTexZ(sector_t::ceiling));
*ptexbot = *ptextop - textureheight;
}

24
src/p_acs.cpp
View file

@ -1898,18 +1898,8 @@ void DLevelScript::ChangeFlat (int tag, int name, bool floorOrCeiling)
while ((secnum = P_FindSectorFromTag (tag, secnum)) >= 0)
{
if (floorOrCeiling == false)
{
if (sectors[secnum].floorpic != flat)
{
sectors[secnum].floorpic = flat;
sectors[secnum].AdjustFloorClip ();
}
}
else
{
sectors[secnum].ceilingpic = flat;
}
int pos = floorOrCeiling? sector_t::ceiling : sector_t::floor;
sectors[secnum].SetTexture(pos, flat);
}
}
@ -2000,8 +1990,10 @@ void DLevelScript::ReplaceTextures (int fromnamei, int tonamei, int flags)
{
sector_t *sec = &sectors[i];
if (!(flags & NOT_FLOOR) && sec->floorpic == picnum1) sec->floorpic = picnum2;
if (!(flags & NOT_CEILING) && sec->ceilingpic == picnum1) sec->ceilingpic = picnum2;
if (!(flags & NOT_FLOOR) && sec->GetTexture(sector_t::floor) == picnum1)
sec->SetTexture(sector_t::floor, picnum2);
if (!(flags & NOT_CEILING) && sec->GetTexture(sector_t::ceiling) == picnum1)
sec->SetTexture(sector_t::ceiling, picnum2);
}
}
}
@ -5321,7 +5313,7 @@ int DLevelScript::RunScript ()
if (actor != NULL)
{
FTexture *tex = TexMan.FindTexture(FBehavior::StaticLookupString(STACK(1)));
STACK(2) = (tex == TexMan[actor->Sector->ceilingpic]);
STACK(2) = (tex == TexMan[actor->Sector->GetTexture(sector_t::ceiling)]);
}
else STACK(2)=0;
sp--;
@ -5334,7 +5326,7 @@ int DLevelScript::RunScript ()
if (actor != NULL)
{
FTexture *tex = TexMan.FindTexture(FBehavior::StaticLookupString(STACK(1)));
STACK(2) = (tex == TexMan[actor->Sector->floorpic]);
STACK(2) = (tex == TexMan[actor->Sector->GetTexture(sector_t::floor)]);
}
else STACK(2)=0;
sp--;

26
src/p_buildmap.cpp
View file

@ -369,38 +369,38 @@ static void LoadSectors (sectortype *bsec)
bsec->ceilingstat = WORD(bsec->ceilingstat);
bsec->floorstat = WORD(bsec->floorstat);
sec->floortexz = -(LittleLong(bsec->floorz) << 8);
sec->floorplane.d = -sec->floortexz;
sec->SetPlaneTexZ(sector_t::floor, -(LittleLong(bsec->floorz) << 8));
sec->floorplane.d = -sec->GetPlaneTexZ(sector_t::floor);
sec->floorplane.c = FRACUNIT;
sec->floorplane.ic = FRACUNIT;
mysnprintf (tnam, countof(tnam), "BTIL%04d", LittleShort(bsec->floorpicnum));
sec->floorpic = TexMan.GetTexture (tnam, FTexture::TEX_Build);
sec->SetTexture(sector_t::floor, TexMan.GetTexture (tnam, FTexture::TEX_Build));
sec->SetXScale(sector_t::floor, (bsec->floorstat & 8) ? FRACUNIT*2 : FRACUNIT);
sec->SetYScale(sector_t::floor, (bsec->floorstat & 8) ? FRACUNIT*2 : FRACUNIT);
sec->SetXOffset(sector_t::floor, (bsec->floorxpanning << FRACBITS) + (32 << FRACBITS));
sec->SetYOffset(sector_t::floor, bsec->floorypanning << FRACBITS);
sec->FloorLight = SHADE2LIGHT (bsec->floorshade);
sec->FloorFlags = SECF_ABSLIGHTING;
sec->SetPlaneLight(sector_t::floor, SHADE2LIGHT (bsec->floorshade));
sec->ChangeFlags(sector_t::floor, 0, SECF_ABSLIGHTING);
sec->ceilingtexz = -(LittleLong(bsec->ceilingz) << 8);
sec->ceilingplane.d = sec->ceilingtexz;
sec->SetPlaneTexZ(sector_t::ceiling, -(LittleLong(bsec->ceilingz) << 8));
sec->ceilingplane.d = sec->GetPlaneTexZ(sector_t::ceiling);
sec->ceilingplane.c = -FRACUNIT;
sec->ceilingplane.ic = -FRACUNIT;
mysnprintf (tnam, countof(tnam), "BTIL%04d", LittleShort(bsec->ceilingpicnum));
sec->ceilingpic = TexMan.GetTexture (tnam, FTexture::TEX_Build);
sec->SetTexture(sector_t::ceiling, TexMan.GetTexture (tnam, FTexture::TEX_Build));
if (bsec->ceilingstat & 1)
{
sky1texture = sky2texture = sec->ceilingpic;
sec->ceilingpic = skyflatnum;
sky1texture = sky2texture = sec->GetTexture(sector_t::ceiling);
sec->SetTexture(sector_t::ceiling, skyflatnum);
}
sec->SetXScale(sector_t::ceiling, (bsec->ceilingstat & 8) ? FRACUNIT*2 : FRACUNIT);
sec->SetYScale(sector_t::ceiling, (bsec->ceilingstat & 8) ? FRACUNIT*2 : FRACUNIT);
sec->SetXOffset(sector_t::ceiling, (bsec->ceilingxpanning << FRACBITS) + (32 << FRACBITS));
sec->SetYOffset(sector_t::ceiling, bsec->ceilingypanning << FRACBITS);
sec->CeilingLight = SHADE2LIGHT (bsec->ceilingshade);
sec->CeilingFlags = SECF_ABSLIGHTING;
sec->SetPlaneLight(sector_t::ceiling, SHADE2LIGHT (bsec->ceilingshade));
sec->ChangeFlags(sector_t::ceiling, 0, SECF_ABSLIGHTING);
sec->lightlevel = (sec->FloorLight + sec->CeilingLight) / 2;
sec->lightlevel = (sec->GetPlaneLight(sector_t::floor) + sec->GetPlaneLight(sector_t::ceiling)) / 2;
sec->seqType = -1;
sec->nextsec = -1;

8
src/p_ceiling.cpp
View file

@ -110,7 +110,7 @@ void DCeiling::Tick ()
m_Sector->special = m_NewSpecial;
// fall through
case genCeilingChg:
m_Sector->ceilingpic = m_Texture;
m_Sector->SetTexture(sector_t::ceiling, m_Texture);
// fall through
default:
SN_StopSequence (m_Sector);
@ -143,7 +143,7 @@ void DCeiling::Tick ()
m_Sector->special = m_NewSpecial;
// fall through
case genCeilingChg:
m_Sector->ceilingpic = m_Texture;
m_Sector->SetTexture(sector_t::ceiling, m_Texture);
// fall through
default:
SN_StopSequence (m_Sector);
@ -421,7 +421,7 @@ manual_ceiling:
sec->FindModelCeilingSector (targheight);
if (modelsec != NULL)
{
ceiling->m_Texture = modelsec->ceilingpic;
ceiling->m_Texture = modelsec->GetTexture(sector_t::ceiling);
switch (change & 3)
{
case 1: // type is zeroed
@ -440,7 +440,7 @@ manual_ceiling:
}
else if (line) // else if a trigger model change
{
ceiling->m_Texture = line->frontsector->ceilingpic;
ceiling->m_Texture = line->frontsector->GetTexture(sector_t::ceiling);
switch (change & 3)
{
case 1: // type is zeroed

45
src/p_floor.cpp
View file

@ -180,8 +180,7 @@ void DFloor::Tick ()
m_Sector->special = (m_Sector->special & SECRET_MASK) | m_NewSpecial;
//fall thru
case genFloorChg:
m_Sector->floorpic = m_Texture;
m_Sector->AdjustFloorClip ();
m_Sector->SetTexture(sector_t::floor, m_Texture);
break;
default:
break;
@ -197,8 +196,7 @@ void DFloor::Tick ()
m_Sector->special = (m_Sector->special & SECRET_MASK) | m_NewSpecial;
//fall thru
case genFloorChg:
m_Sector->floorpic = m_Texture;
m_Sector->AdjustFloorClip ();
m_Sector->SetTexture(sector_t::floor, m_Texture);
break;
default:
break;
@ -299,7 +297,7 @@ void DElevator::Tick ()
void DFloor::SetFloorChangeType (sector_t *sec, int change)
{
m_Texture = sec->floorpic;
m_Texture = sec->GetTexture(sector_t::floor);
switch (change & 3)
{
@ -517,13 +515,9 @@ manual_floor:
floor->m_FloorDestDist = sec->floorplane.PointToDist (0, 0, newheight);
if (line != NULL)
{
FTextureID oldpic = sec->floorpic;
sec->floorpic = line->frontsector->floorpic;
FTextureID oldpic = sec->GetTexture(sector_t::floor);
sec->SetTexture(sector_t::floor, line->frontsector->GetTexture(sector_t::floor));
sec->special = (sec->special & SECRET_MASK) | (line->frontsector->special & ~SECRET_MASK);
if (oldpic != sec->floorpic)
{
sec->AdjustFloorClip ();
}
}
else
{
@ -535,7 +529,7 @@ manual_floor:
floor->m_Direction = -1;
newheight = sec->FindLowestFloorSurrounding (&spot);
floor->m_FloorDestDist = sec->floorplane.PointToDist (spot, newheight);
floor->m_Texture = sec->floorpic;
floor->m_Texture = sec->GetTexture(sector_t::floor);
// jff 1/24/98 make sure floor->m_NewSpecial gets initialized
// in case no surrounding sector is at floordestheight
// --> should not affect compatibility <--
@ -546,7 +540,7 @@ manual_floor:
modelsec = sec->FindModelFloorSector (newheight);
if (modelsec != NULL)
{
floor->m_Texture = modelsec->floorpic;
floor->m_Texture = modelsec->GetTexture(sector_t::floor);
floor->m_NewSpecial = modelsec->special & ~SECRET_MASK;
}
break;
@ -659,14 +653,14 @@ bool EV_DoChange (line_t *line, EChange changetype, int tag)
rtn = true;
// handle trigger or numeric change type
FTextureID oldpic = sec->floorpic;
FTextureID oldpic = sec->GetTexture(sector_t::floor);
switch(changetype)
{
case trigChangeOnly:
if (line)
{ // [RH] if no line, no change
sec->floorpic = line->frontsector->floorpic;
sec->SetTexture(sector_t::floor, line->frontsector->GetTexture(sector_t::floor));
sec->special = (sec->special & SECRET_MASK) | (line->frontsector->special & ~SECRET_MASK);
}
break;
@ -674,18 +668,13 @@ bool EV_DoChange (line_t *line, EChange changetype, int tag)
secm = sec->FindModelFloorSector (sec->CenterFloor());
if (secm)
{ // if no model, no change
sec->floorpic = secm->floorpic;
sec->SetTexture(sector_t::floor, secm->GetTexture(sector_t::floor));
sec->special = secm->special;
}
break;
default:
break;
}
if (oldpic != sec->floorpic)
{
sec->AdjustFloorClip ();
}
}
return rtn;
}
@ -787,7 +776,7 @@ manual_stair:
height = sec->floorplane.ZatPoint (0, 0) + stairstep;
floor->m_FloorDestDist = sec->floorplane.PointToDist (0, 0, height);
texture = sec->floorpic;
texture = sec->GetTexture(sector_t::floor);
osecnum = secnum; //jff 3/4/98 preserve loop index
// Find next sector to raise
@ -837,7 +826,7 @@ manual_stair:
if (!tsec) continue; //jff 5/7/98 if no backside, continue
newsecnum = (int)(tsec - sectors);
if (!igntxt && tsec->floorpic != texture)
if (!igntxt && tsec->GetTexture(sector_t::floor) != texture)
continue;
height += stairstep;
@ -954,7 +943,7 @@ bool EV_DoDonut (int tag, fixed_t pillarspeed, fixed_t slimespeed)
floor->m_Direction = 1;
floor->m_Sector = s2;
floor->m_Speed = slimespeed;
floor->m_Texture = s3->floorpic;
floor->m_Texture = s3->GetTexture(sector_t::floor);
floor->m_NewSpecial = 0;
height = s3->FindHighestFloorPoint (&spot);
floor->m_FloorDestDist = s2->floorplane.PointToDist (spot, height);
@ -1110,18 +1099,18 @@ void DWaggleBase::Destroy()
void DWaggleBase::DoWaggle (bool ceiling)
{
secplane_t *plane;
fixed_t *texz;
int pos;
fixed_t dist;
if (ceiling)
{
plane = &m_Sector->ceilingplane;
texz = &m_Sector->ceilingtexz;
pos = sector_t::ceiling;
}
else
{
plane = &m_Sector->floorplane;
texz = &m_Sector->floortexz;
pos = sector_t::floor;
}
switch (m_State)
@ -1138,7 +1127,7 @@ void DWaggleBase::DoWaggle (bool ceiling)
if ((m_Scale -= m_ScaleDelta) <= 0)
{ // Remove
dist = FixedMul (m_OriginalDist - plane->d, plane->ic);
*texz -= plane->HeightDiff (m_OriginalDist);
m_Sector->ChangePlaneTexZ(pos, -plane->HeightDiff (m_OriginalDist));
plane->d = m_OriginalDist;
P_ChangeSector (m_Sector, true, dist, ceiling, false);
if (ceiling)

8
src/p_linkedsectors.cpp
View file

@ -92,14 +92,14 @@ bool sector_t::IsLinked(sector_t *other, bool ceiling) const
static bool MoveCeiling(sector_t *sector, int crush, fixed_t move)
{
sector->ceilingplane.ChangeHeight (move);
sector->ceilingtexz += move;
sector->ChangePlaneTexZ(sector_t::ceiling, move);
if (P_ChangeSector(sector, crush, move, 1, true)) return false;
// Don't let the ceiling go below the floor
if ((sector->ceilingplane.a | sector->ceilingplane.b |
sector->floorplane.a | sector->floorplane.b) == 0 &&
sector->floortexz > sector->ceilingtexz) return false;
sector->GetPlaneTexZ(sector_t::floor) > sector->GetPlaneTexZ(sector_t::ceiling)) return false;
return true;
}
@ -107,14 +107,14 @@ static bool MoveCeiling(sector_t *sector, int crush, fixed_t move)
static bool MoveFloor(sector_t *sector, int crush, fixed_t move)
{
sector->floorplane.ChangeHeight (move);
sector->floortexz += move;
sector->ChangePlaneTexZ(sector_t::floortexz, move);
if (P_ChangeSector(sector, crush, move, 0, true)) return false;
// Don't let the floor go above the ceiling
if ((sector->ceilingplane.a | sector->ceilingplane.b |
sector->floorplane.a | sector->floorplane.b) == 0 &&
sector->floortexz > sector->ceilingtexz) return false;
sector->GetPlaneTexZ(sector_t::floor) > sector->GetPlaneTexZ(sector_t::ceiling)) return false;
return true;
}

18
src/p_map.cpp
View file

@ -180,9 +180,9 @@ void P_FindFloorCeiling (AActor *actor, bool onlymidtex)
tmf.thing = actor;
tmf.floorz = tmf.dropoffz = sec->floorplane.ZatPoint (tmf.x, tmf.y);
tmf.ceilingz = sec->ceilingplane.ZatPoint (tmf.x, tmf.y);
tmf.floorpic = sec->floorpic;
tmf.floorpic = sec->GetTexture(sector_t::floor);
tmf.floorsector = sec;
tmf.ceilingpic = sec->ceilingpic;
tmf.ceilingpic = sec->GetTexture(sector_t::ceiling);
tmf.ceilingsector = sec;
tmf.touchmidtex = false;
validcount++;
@ -239,9 +239,9 @@ bool P_TeleportMove (AActor *thing, fixed_t x, fixed_t y, fixed_t z, bool telefr
tmf.z = z;
tmf.floorz = tmf.dropoffz = newsec->floorplane.ZatPoint (x, y);
tmf.ceilingz = newsec->ceilingplane.ZatPoint (x, y);
tmf.floorpic = newsec->floorpic;
tmf.floorpic = newsec->GetTexture(sector_t::floor);
tmf.floorsector = newsec;
tmf.ceilingpic = newsec->ceilingpic;
tmf.ceilingpic = newsec->GetTexture(sector_t::ceiling);
tmf.ceilingsector = newsec;
spechit.Clear ();
@ -365,13 +365,13 @@ void P_PlayerStartStomp (AActor *actor)
inline fixed_t secfriction (const sector_t *sec)
{
fixed_t friction = Terrains[TerrainTypes[sec->floorpic]].Friction;
fixed_t friction = Terrains[TerrainTypes[sec->GetTexture(sector_t::floor)]].Friction;
return friction != 0 ? friction : sec->friction;
}
inline fixed_t secmovefac (const sector_t *sec)
{
fixed_t movefactor = Terrains[TerrainTypes[sec->floorpic]].MoveFactor;
fixed_t movefactor = Terrains[TerrainTypes[sec->GetTexture(sector_t::floor)]].MoveFactor;
return movefactor != 0 ? movefactor : sec->movefactor;
}
@ -408,7 +408,7 @@ int P_GetFriction (const AActor *mo, int *frictionfactor)
{
sec = m->m_sector;
if (!(sec->special & FRICTION_MASK) &&
Terrains[TerrainTypes[sec->floorpic]].Friction == 0)
Terrains[TerrainTypes[sec->GetTexture(sector_t::floor)]].Friction == 0)
{
continue;
}
@ -1025,9 +1025,9 @@ bool P_CheckPosition (AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm)
// Any contacted lines the step closer together will adjust them.
tm.floorz = tm.dropoffz = newsec->floorplane.ZatPoint (x, y);
tm.ceilingz = newsec->ceilingplane.ZatPoint (x, y);
tm.floorpic = newsec->floorpic;
tm.floorpic = newsec->GetTexture(sector_t::floor);
tm.floorsector = newsec;
tm.ceilingpic = newsec->ceilingpic;
tm.ceilingpic = newsec->GetTexture(sector_t::ceiling);
tm.ceilingsector = newsec;
tm.touchmidtex = false;

6
src/p_maputl.cpp
View file

@ -157,7 +157,7 @@ void P_LineOpening (FLineOpening &open, AActor *actor, const line_t *linedef,
/*Printf ("]]]]]] %d %d\n", ff, bf);*/
open.topsec = fc < bc? front : back;
open.ceilingpic = open.topsec->ceilingpic;
open.ceilingpic = open.topsec->GetTexture(sector_t::ceiling);
open.top = fc < bc ? fc : bc;
bool usefront;
@ -186,14 +186,14 @@ void P_LineOpening (FLineOpening &open, AActor *actor, const line_t *linedef,
{
open.bottom = ff;
open.bottomsec = front;
open.floorpic = front->floorpic;
open.floorpic = front->GetTexture(sector_t::floor);
open.lowfloor = bf;
}
else
{
open.bottom = bf;
open.bottomsec = back;
open.floorpic = back->floorpic;
open.floorpic = back->GetTexture(sector_t::floor);
open.lowfloor = ff;
}

18
src/p_mobj.cpp
View file

@ -1635,7 +1635,7 @@ explode:
// explode a missile
if (tm.ceilingline &&
tm.ceilingline->backsector &&
tm.ceilingline->backsector->ceilingpic == skyflatnum &&
tm.ceilingline->backsector->GetTexture(sector_t::ceiling) == skyflatnum &&
mo->z >= tm.ceilingline->backsector->ceilingplane.ZatPoint (mo->x, mo->y) && //killough
!(mo->flags3 & MF3_SKYEXPLODE))
{
@ -3108,9 +3108,9 @@ AActor *AActor::StaticSpawn (const PClass *type, fixed_t ix, fixed_t iy, fixed_t
actor->floorz = actor->Sector->floorplane.ZatPoint (ix, iy);
actor->ceilingz = actor->Sector->ceilingplane.ZatPoint (ix, iy);
actor->floorsector = actor->Sector;
actor->floorpic = actor->floorsector->floorpic;
actor->floorpic = actor->floorsector->GetTexture(sector_t::floor);
actor->ceilingsector = actor->Sector;
actor->ceilingpic = actor->ceilingsector->ceilingpic;
actor->ceilingpic = actor->ceilingsector->GetTexture(sector_t::ceiling);
// Check if there's something solid to stand on between the current position and the
// current sector's floor.
P_FindFloorCeiling(actor, true);
@ -3124,9 +3124,9 @@ AActor *AActor::StaticSpawn (const PClass *type, fixed_t ix, fixed_t iy, fixed_t
actor->floorz = FIXED_MIN;
actor->dropoffz = FIXED_MIN;
actor->ceilingz = FIXED_MAX;
actor->floorpic = actor->Sector->floorpic;
actor->floorpic = actor->Sector->GetTexture(sector_t::floor);
actor->floorsector = actor->Sector;
actor->ceilingpic = actor->Sector->ceilingpic;
actor->ceilingpic = actor->Sector->GetTexture(sector_t::ceiling);
actor->ceilingsector = actor->Sector;
}
@ -3363,7 +3363,7 @@ void AActor::AdjustFloorClip ()
m->m_sector->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC) &&
m->m_sector->floorplane.ZatPoint (x, y) == z)
{
fixed_t clip = Terrains[TerrainTypes[m->m_sector->floorpic]].FootClip;
fixed_t clip = Terrains[TerrainTypes[m->m_sector->GetTexture(sector_t::floor)]].FootClip;
if (clip < shallowestclip)
{
shallowestclip = clip;
@ -4182,7 +4182,7 @@ int P_GetThingFloorType (AActor *thing)
}
else
{
return TerrainTypes[thing->Sector->floorpic];
return TerrainTypes[thing->Sector->GetTexture(sector_t::floor)];
}
}
@ -4213,11 +4213,11 @@ bool P_HitWater (AActor * thing, sector_t * sec, fixed_t z)
(sec->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC) ||
!(sec->heightsec->MoreFlags & SECF_CLIPFAKEPLANES))
{
terrainnum = TerrainTypes[sec->floorpic];
terrainnum = TerrainTypes[sec->GetTexture(sector_t::floor)];
}
else
{
terrainnum = TerrainTypes[sec->heightsec->floorpic];
terrainnum = TerrainTypes[sec->heightsec->GetTexture(sector_t::floor)];
}
int splashnum = Terrains[terrainnum].Splash;

2
src/p_plats.cpp
View file

@ -261,7 +261,7 @@ manual_plat:
if (change)
{
if (line)
sec->floorpic = sides[line->sidenum[0]].sector->floorpic;
sec->SetTexture(sector_t::floor, sides[line->sidenum[0]].sector->GetTexture(sector_t::floor));
if (change == 1)
sec->special &= SECRET_MASK; // Stop damage and other stuff, if any
}

11
src/p_saveg.cpp
View file

@ -291,10 +291,6 @@ void P_SerializeWorld (FArchive &arc)
{
arc << sec->floorplane
<< sec->ceilingplane
<< sec->floortexz
<< sec->ceilingtexz
<< sec->floorpic
<< sec->ceilingpic
<< sec->lightlevel
<< sec->special
<< sec->tag
@ -317,10 +313,6 @@ void P_SerializeWorld (FArchive &arc)
<< sec->mod
<< sec->SoundTarget
<< sec->SecActTarget
<< sec->FloorLight
<< sec->CeilingLight
<< sec->FloorFlags
<< sec->CeilingFlags
<< sec->sky
<< sec->MoreFlags
<< sec->Flags
@ -415,7 +407,8 @@ FArchive &operator<< (FArchive &arc, side_t::part &p)
FArchive &operator<< (FArchive &arc, sector_t::splane &p)
{
arc << p.xform.xoffs << p.xform.yoffs << p.xform.xscale << p.xform.yscale
<< p.xform.angle << p.xform.base_yoffs << p.xform.base_angle;
<< p.xform.angle << p.xform.base_yoffs << p.xform.base_angle
<< p.Flags << p.Light << p.Texture << p.TexZ;
return arc;
}

4
src/p_sectors.cpp
View file

@ -63,7 +63,7 @@ fixed_t sector_t::FindLowestFloorSurrounding (vertex_t **v) const
fixed_t ofloor;
vertex_t *spot;
if (linecount == 0) return floortexz;
if (linecount == 0) return GetPlaneTexZ(sector_t::floor);
spot = lines[0]->v1;
floor = floorplane.ZatPoint (spot);
@ -270,7 +270,7 @@ fixed_t sector_t::FindNextLowestCeiling (vertex_t **v) const
int i;
if (linecount == 0) return ceilingtexz;
if (linecount == 0) return GetPlaneTexZ(sector_t::ceiling);
spot = lines[0]->v1;
height = ceilingplane.ZatPoint (spot);

14
src/p_setup.cpp
View file

@ -1186,18 +1186,18 @@ void P_LoadSectors (MapData * map)
{
ss->e = &sectors[0].e[i];
if (!map->HasBehavior) ss->Flags |= SECF_FLOORDROP;
ss->floortexz = LittleShort(ms->floorheight)<<FRACBITS;
ss->floorplane.d = -ss->floortexz;
ss->SetPlaneTexZ(sector_t::floor, LittleShort(ms->floorheight)<<FRACBITS);
ss->floorplane.d = -ss->GetPlaneTexZ(sector_t::floor);
ss->floorplane.c = FRACUNIT;
ss->floorplane.ic = FRACUNIT;
ss->ceilingtexz = LittleShort(ms->ceilingheight)<<FRACBITS;
ss->ceilingplane.d = ss->ceilingtexz;
ss->SetPlaneTexZ(sector_t::ceiling, LittleShort(ms->ceilingheight)<<FRACBITS);
ss->ceilingplane.d = ss->GetPlaneTexZ(sector_t::ceiling);
ss->ceilingplane.c = -FRACUNIT;
ss->ceilingplane.ic = -FRACUNIT;
strncpy (fname, ms->floorpic, 8);
ss->floorpic = TexMan.GetTexture (fname, FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable);
ss->SetTexture(sector_t::floor, TexMan.GetTexture (fname, FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable));
strncpy (fname, ms->ceilingpic, 8);
ss->ceilingpic = TexMan.GetTexture (fname, FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable);
ss->SetTexture(sector_t::ceiling, TexMan.GetTexture (fname, FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable));
ss->lightlevel = clamp (LittleShort(ms->lightlevel), (short)0, (short)255);
if (map->HasBehavior)
ss->special = LittleShort(ms->special);
@ -1225,7 +1225,7 @@ void P_LoadSectors (MapData * map)
// [RH] Sectors default to white light with the default fade.
// If they are outside (have a sky ceiling), they use the outside fog.
if (level.outsidefog != 0xff000000 && (ss->ceilingpic == skyflatnum || (ss->special&0xff) == Sector_Outside))
if (level.outsidefog != 0xff000000 && (ss->GetTexture(sector_t::ceiling) == skyflatnum || (ss->special&0xff) == Sector_Outside))
{
if (fogMap == NULL)
fogMap = GetSpecialLights (PalEntry (255,255,255), level.outsidefog, 0);

8
src/p_slopes.cpp
View file

@ -209,7 +209,7 @@ void P_VavoomSlope(sector_t * sec, int id, fixed_t x, fixed_t y, fixed_t z, int
{
FVector3 v1, v2, cross;
secplane_t *srcplane = (which == 0) ? &sec->floorplane : &sec->ceilingplane;
fixed_t srcheight = (which == 0) ? sec->floortexz : sec->ceilingtexz;
fixed_t srcheight = (which == 0) ? sec->GetPlaneTexZ(sector_t::floor) : sec->GetPlaneTexZ(sector_t::ceiling);
v1[0] = FIXED2FLOAT (x - l->v2->x);
v1[1] = FIXED2FLOAT (y - l->v2->y);
@ -327,9 +327,9 @@ static void P_SetSlopesFromVertexHeights(FMapThing *firstmt, FMapThing *lastmt)
fixed_t z3;
if (h1==NULL && h2==NULL && h3==NULL) continue;
vt1.Z = FIXED2FLOAT(h1? *h1 : j==0? sec->floortexz : sec->ceilingtexz);
vt2.Z = FIXED2FLOAT(h2? *h2 : j==0? sec->floortexz : sec->ceilingtexz);
z3 = h3? *h3 : j==0? sec->floortexz : sec->ceilingtexz;
vt1.Z = FIXED2FLOAT(h1? *h1 : j==0? sec->GetPlaneTexZ(sector_t::floor) : sec->GetPlaneTexZ(sector_t::ceiling));
vt2.Z = FIXED2FLOAT(h2? *h2 : j==0? sec->GetPlaneTexZ(sector_t::floor) : sec->GetPlaneTexZ(sector_t::ceiling));
z3 = h3? *h3 : j==0? sec->GetPlaneTexZ(sector_t::floor) : sec->GetPlaneTexZ(sector_t::ceiling);
vt3.Z = FIXED2FLOAT(z3);
if (P_PointOnLineSide(vertexes[vi3].x, vertexes[vi3].y, sec->lines[0]) == 0)

8
src/p_spec.cpp
View file

@ -684,12 +684,12 @@ DLightTransfer::DLightTransfer (sector_t *srcSec, int target, bool copyFloor)
if (copyFloor)
{
for (secnum = -1; (secnum = P_FindSectorFromTag (target, secnum)) >= 0; )
sectors[secnum].FloorFlags |= SECF_ABSLIGHTING;
sectors[secnum].ChangeFlags(sector_t::floor, 0, SECF_ABSLIGHTING);
}
else
{
for (secnum = -1; (secnum = P_FindSectorFromTag (target, secnum)) >= 0; )
sectors[secnum].CeilingFlags |= SECF_ABSLIGHTING;
sectors[secnum].ChangeFlags(sector_t::ceiling, 0, SECF_ABSLIGHTING);
}
ChangeStatNum (STAT_LIGHTTRANSFER);
}
@ -712,12 +712,12 @@ void DLightTransfer::DoTransfer (BYTE level, int target, bool floor)
if (floor)
{
for (secnum = -1; (secnum = P_FindSectorFromTag (target, secnum)) >= 0; )
sectors[secnum].FloorLight = level;
sectors[secnum].SetPlaneLight(sector_t::floor, level);
}
else
{
for (secnum = -1; (secnum = P_FindSectorFromTag (target, secnum)) >= 0; )
sectors[secnum].CeilingLight = level;
sectors[secnum].SetPlaneLight(sector_t::ceiling, level);
}
}

8
src/p_trace.cpp
View file

@ -419,7 +419,7 @@ static bool EditTraceResult (DWORD flags, FTraceResults &res)
{ // Throw away sky hits
if (res.HitType == TRACE_HitFloor)
{
if (res.Sector->floorpic == skyflatnum)
if (res.Sector->GetTexture(sector_t::floor) == skyflatnum)
{
res.HitType = TRACE_HitNone;
return false;
@ -427,7 +427,7 @@ static bool EditTraceResult (DWORD flags, FTraceResults &res)
}
else if (res.HitType == TRACE_HitCeiling)
{
if (res.Sector->ceilingpic == skyflatnum)
if (res.Sector->GetTexture(sector_t::ceiling) == skyflatnum)
{
res.HitType = TRACE_HitNone;
return false;
@ -436,8 +436,8 @@ static bool EditTraceResult (DWORD flags, FTraceResults &res)
else if (res.HitType == TRACE_HitWall)
{
if (res.Tier == TIER_Upper &&
res.Line->frontsector->ceilingpic == skyflatnum &&
res.Line->backsector->ceilingpic == skyflatnum)
res.Line->frontsector->GetTexture(sector_t::ceiling) == skyflatnum &&
res.Line->backsector->GetTexture(sector_t::ceiling) == skyflatnum)
{
res.HitType = TRACE_HitNone;
return false;

26
src/p_udmf.cpp
View file

@ -800,19 +800,19 @@ struct UDMFParser
switch(key)
{
case NAME_Heightfloor:
sec->floortexz = CheckInt(key) << FRACBITS;
sec->SetPlaneTexZ(sector_t::floor, CheckInt(key) << FRACBITS);
break;
case NAME_Heightceiling:
sec->ceilingtexz = CheckInt(key) << FRACBITS;
sec->SetPlaneTexZ(sector_t::ceiling, CheckInt(key) << FRACBITS);
break;
case NAME_Texturefloor:
sec->floorpic = TexMan.GetTexture (CheckString(key), FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable);
sec->SetTexture(sector_t::floor, TexMan.GetTexture (CheckString(key), FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable));
break;
case NAME_Textureceiling:
sec->ceilingpic = TexMan.GetTexture (CheckString(key), FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable);
sec->SetTexture(sector_t::ceiling, TexMan.GetTexture (CheckString(key), FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable));
break;
case NAME_Lightlevel:
@ -880,21 +880,21 @@ struct UDMFParser
break;
case NAME_Lightfloor:
sec->FloorLight = CheckInt(key);
sec->SetPlaneLight(sector_t::floor, CheckInt(key));
break;
case NAME_Lightceiling:
sec->CeilingLight = CheckInt(key);
sec->SetPlaneLight(sector_t::ceiling, CheckInt(key));
break;
case NAME_Lightfloorabsolute:
if (CheckBool(key)) sec->FloorFlags |= SECF_ABSLIGHTING;
else sec->FloorFlags &= ~SECF_ABSLIGHTING;
if (CheckBool(key)) sec->ChangeFlags(sector_t::floor, 0, SECF_ABSLIGHTING);
else sec->ChangeFlags(sector_t::floor, SECF_ABSLIGHTING, 0);
break;
case NAME_Lightceilingabsolute:
if (CheckBool(key)) sec->CeilingFlags |= SECF_ABSLIGHTING;
else sec->CeilingFlags &= ~SECF_ABSLIGHTING;
if (CheckBool(key)) sec->ChangeFlags(sector_t::ceiling, 0, SECF_ABSLIGHTING);
else sec->ChangeFlags(sector_t::ceiling, SECF_ABSLIGHTING, 0);
break;
case NAME_Gravity:
@ -932,16 +932,16 @@ struct UDMFParser
sc.MustGetToken(';');
}
sec->floorplane.d = -sec->floortexz;
sec->floorplane.d = -sec->GetPlaneTexZ(sector_t::floor);
sec->floorplane.c = FRACUNIT;
sec->floorplane.ic = FRACUNIT;
sec->ceilingplane.d = sec->ceilingtexz;
sec->ceilingplane.d = sec->GetPlaneTexZ(sector_t::ceiling);
sec->ceilingplane.c = -FRACUNIT;
sec->ceilingplane.ic = -FRACUNIT;
// [RH] Sectors default to white light with the default fade.
// If they are outside (have a sky ceiling), they use the outside fog.
if (level.outsidefog != 0xff000000 && (sec->ceilingpic == skyflatnum || (sec->special&0xff) == Sector_Outside))
if (level.outsidefog != 0xff000000 && (sec->GetTexture(sector_t::ceiling) == skyflatnum || (sec->special&0xff) == Sector_Outside))
{
if (fogMap == NULL)
fogMap = GetSpecialLights (PalEntry (255,255,255), level.outsidefog, 0);

8
src/p_writemap.cpp
View file

@ -242,10 +242,10 @@ static int WriteSECTORS (FILE *file)
for (int i = 0; i < numsectors; ++i)
{
ms.floorheight = LittleShort(short(sectors[i].floortexz >> FRACBITS));
ms.ceilingheight = LittleShort(short(sectors[i].ceilingtexz >> FRACBITS));
uppercopy (ms.floorpic, GetTextureName (sectors[i].floorpic));
uppercopy (ms.ceilingpic, GetTextureName (sectors[i].ceilingpic));
ms.floorheight = LittleShort(short(sectors[i].GetPlaneTexZ(sector_t::floor) >> FRACBITS));
ms.ceilingheight = LittleShort(short(sectors[i].GetPlaneTexZ(sector_t::ceiling) >> FRACBITS));
uppercopy (ms.floorpic, GetTextureName (sectors[i].GetTexture(sector_t::floor)));
uppercopy (ms.ceilingpic, GetTextureName (sectors[i].GetTexture(sector_t::ceiling)));
ms.lightlevel = LittleShort(sectors[i].lightlevel);
ms.special = LittleShort(sectors[i].special);
ms.tag = LittleShort(sectors[i].tag);

60
src/r_bsp.cpp
View file

@ -269,25 +269,25 @@ void R_ClearClipSegs (short left, short right)
int GetFloorLight (const sector_t *sec)
{
if (sec->FloorFlags & SECF_ABSLIGHTING)
if (sec->GetFlags(sector_t::floor) & SECF_ABSLIGHTING)
{
return sec->FloorLight;
return sec->GetPlaneLight(sector_t::floor);
}
else
{
return clamp (sec->lightlevel + (SBYTE)sec->FloorLight, 0, 255);
return clamp (sec->lightlevel + sec->GetPlaneLight(sector_t::floor), 0, 255);
}
}
int GetCeilingLight (const sector_t *sec)
{
if (sec->CeilingFlags & SECF_ABSLIGHTING)
if (sec->GetFlags(sector_t::ceiling) & SECF_ABSLIGHTING)
{
return sec->CeilingLight;
return sec->GetPlaneLight(sector_t::ceiling);
}
else
{
return clamp (sec->lightlevel + (SBYTE)sec->CeilingLight, 0, 255);
return clamp (sec->lightlevel + sec->GetPlaneLight(sector_t::ceiling), 0, 255);
}
}
@ -368,7 +368,7 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec,
{
if (CopyPlaneIfValid (&tempsec->floorplane, &s->floorplane, &sec->ceilingplane))
{
tempsec->floorpic = s->floorpic;
tempsec->SetTexture(sector_t::floor, s->GetTexture(sector_t::floor), false);
}
else if (s->MoreFlags & SECF_FAKEFLOORONLY)
{
@ -406,7 +406,7 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec,
{
if (CopyPlaneIfValid (&tempsec->ceilingplane, &s->ceilingplane, &sec->floorplane))
{
tempsec->ceilingpic = s->ceilingpic;
tempsec->SetTexture(sector_t::ceiling, s->GetTexture(sector_t::ceiling), false);
}
}
else
@ -456,23 +456,23 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec,
// killough 11/98: prevent sudden light changes from non-water sectors:
if ((underwater && !back) || doorunderwater)
{ // head-below-floor hack
tempsec->floorpic = diffTex ? sec->floorpic : s->floorpic;
tempsec->SetTexture(sector_t::floor, diffTex ? sec->GetTexture(sector_t::floor) : s->GetTexture(sector_t::floor), false);
tempsec->planes[sector_t::floor].xform = s->planes[sector_t::floor].xform;
tempsec->ceilingplane = s->floorplane;
tempsec->ceilingplane.FlipVert ();
tempsec->ceilingplane.ChangeHeight (-1);
if (s->ceilingpic == skyflatnum)
if (s->GetTexture(sector_t::ceiling) == skyflatnum)
{
tempsec->floorplane = tempsec->ceilingplane;
tempsec->floorplane.FlipVert ();
tempsec->floorplane.ChangeHeight (+1);
tempsec->ceilingpic = tempsec->floorpic;
tempsec->SetTexture(sector_t::ceiling, tempsec->GetTexture(sector_t::floor), false);
tempsec->planes[sector_t::ceiling].xform = tempsec->planes[sector_t::floor].xform;
}
else
{
tempsec->ceilingpic = diffTex ? s->floorpic : s->ceilingpic;
tempsec->SetTexture(sector_t::ceiling, diffTex ? s->GetTexture(sector_t::floor) : s->GetTexture(sector_t::ceiling), false);
tempsec->planes[sector_t::ceiling].xform = s->planes[sector_t::ceiling].xform;
}
@ -502,14 +502,14 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec,
tempsec->ColorMap = s->ColorMap;
tempsec->ColorMap = s->ColorMap;
tempsec->ceilingpic = diffTex ? sec->ceilingpic : s->ceilingpic;
tempsec->floorpic = s->ceilingpic;
tempsec->SetTexture(sector_t::ceiling, diffTex ? sec->GetTexture(sector_t::ceiling) : s->GetTexture(sector_t::ceiling), false);
tempsec->SetTexture(sector_t::floor, s->GetTexture(sector_t::ceiling), false);
tempsec->planes[sector_t::ceiling].xform = tempsec->planes[sector_t::floor].xform = s->planes[sector_t::ceiling].xform;
if (s->floorpic != skyflatnum)
if (s->GetTexture(sector_t::floor) != skyflatnum)
{
tempsec->ceilingplane = sec->ceilingplane;
tempsec->floorpic = s->floorpic;
tempsec->SetTexture(sector_t::floor, s->GetTexture(sector_t::floor), false);
tempsec->planes[sector_t::floor].xform = s->planes[sector_t::floor].xform;
}
@ -723,7 +723,7 @@ void R_AddLine (seg_t *line)
}
else if (
// properly render skies (consider door "open" if both ceilings are sky):
(backsector->ceilingpic != skyflatnum || frontsector->ceilingpic != skyflatnum)
(backsector->GetTexture(sector_t::ceiling) != skyflatnum || frontsector->GetTexture(sector_t::ceiling) != skyflatnum)
// if door is closed because back is shut:
&& rw_backcz1 <= rw_backfz1 && rw_backcz2 <= rw_backfz2
@ -750,8 +750,8 @@ void R_AddLine (seg_t *line)
solid = false;
}
else if (backsector->lightlevel != frontsector->lightlevel
|| backsector->floorpic != frontsector->floorpic
|| backsector->ceilingpic != frontsector->ceilingpic
|| backsector->GetTexture(sector_t::floor) != frontsector->GetTexture(sector_t::floor)
|| backsector->GetTexture(sector_t::ceiling) != frontsector->GetTexture(sector_t::ceiling)
|| curline->sidedef->GetTexture(side_t::mid).isValid()
// killough 3/7/98: Take flats offsets into account:
@ -760,10 +760,10 @@ void R_AddLine (seg_t *line)
|| backsector->GetXOffset(sector_t::ceiling) != frontsector->GetXOffset(sector_t::ceiling)
|| backsector->GetYOffset(sector_t::ceiling) != frontsector->GetYOffset(sector_t::ceiling)
|| backsector->FloorLight != frontsector->FloorLight
|| backsector->CeilingLight != frontsector->CeilingLight
|| backsector->FloorFlags != frontsector->FloorFlags
|| backsector->CeilingFlags != frontsector->CeilingFlags
|| backsector->GetPlaneLight(sector_t::floor) != frontsector->GetPlaneLight(sector_t::floor)
|| backsector->GetPlaneLight(sector_t::ceiling) != frontsector->GetPlaneLight(sector_t::ceiling)
|| backsector->GetFlags(sector_t::floor) != frontsector->GetFlags(sector_t::floor)
|| backsector->GetFlags(sector_t::ceiling) != frontsector->GetFlags(sector_t::ceiling)
// [RH] Also consider colormaps
|| backsector->ColorMap != frontsector->ColorMap
@ -1041,13 +1041,13 @@ void R_Subsector (subsector_t *sub)
r_actualextralight = foggy ? 0 : extralight << 4;
basecolormap = frontsector->ColorMap;
ceilingplane = frontsector->ceilingplane.ZatPoint (viewx, viewy) > viewz ||
frontsector->ceilingpic == skyflatnum ||
frontsector->GetTexture(sector_t::ceiling) == skyflatnum ||
(frontsector->CeilingSkyBox != NULL && frontsector->CeilingSkyBox->bAlways) ||
(frontsector->heightsec &&
!(frontsector->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC) &&
frontsector->heightsec->floorpic == skyflatnum) ?
frontsector->heightsec->GetTexture(sector_t::floor) == skyflatnum) ?
R_FindPlane(frontsector->ceilingplane, // killough 3/8/98
frontsector->ceilingpic,
frontsector->GetTexture(sector_t::ceiling),
ceilinglightlevel + r_actualextralight, // killough 4/11/98
frontsector->GetXOffset(sector_t::ceiling), // killough 3/7/98
frontsector->GetYOffset(sector_t::ceiling), // killough 3/7/98
@ -1065,13 +1065,13 @@ void R_Subsector (subsector_t *sub)
// killough 3/16/98: add floorlightlevel
// killough 10/98: add support for skies transferred from sidedefs
floorplane = frontsector->floorplane.ZatPoint (viewx, viewy) < viewz || // killough 3/7/98
frontsector->floorpic == skyflatnum ||
frontsector->GetTexture(sector_t::floor) == skyflatnum ||
(frontsector->FloorSkyBox != NULL && frontsector->FloorSkyBox->bAlways) ||
(frontsector->heightsec &&
!(frontsector->heightsec->MoreFlags & SECF_IGNOREHEIGHTSEC) &&
frontsector->heightsec->ceilingpic == skyflatnum) ?
frontsector->heightsec->GetTexture(sector_t::ceiling) == skyflatnum) ?
R_FindPlane(frontsector->floorplane,
frontsector->floorpic,
frontsector->GetTexture(sector_t::floor),
floorlightlevel + r_actualextralight, // killough 3/16/98
frontsector->GetXOffset(sector_t::floor), // killough 3/7/98
frontsector->GetYOffset(sector_t::floor), // killough 3/7/98
@ -1087,7 +1087,7 @@ void R_Subsector (subsector_t *sub)
// lightlevels on floor & ceiling lightlevels in the surrounding area.
// [RH] Handle sprite lighting like Duke 3D: If the ceiling is a sky, sprites are lit by
// it, otherwise they are lit by the floor.
R_AddSprites (sub->sector, frontsector->ceilingpic == skyflatnum ?
R_AddSprites (sub->sector, frontsector->GetTexture(sector_t::ceiling) == skyflatnum ?
ceilinglightlevel : floorlightlevel, FakeSide);
// [RH] Add particles

3
src/r_data.cpp
View file

@ -457,7 +457,8 @@ void R_PrecacheLevel (void)
for (i = numsectors - 1; i >= 0; i--)
{
hitlist[sectors[i].floorpic.GetIndex()] = hitlist[sectors[i].ceilingpic.GetIndex()] |= 2;
hitlist[sectors[i].GetTexture(sector_t::floor).GetIndex()] =
hitlist[sectors[i].GetTexture(sector_t::ceiling).GetIndex()] |= 2;
}
for (i = numsides - 1; i >= 0; i--)

55
src/r_defs.h
View file

@ -373,6 +373,10 @@ struct sector_t
struct splane
{
FTransform xform;
int Flags;
int Light;
FTextureID Texture;
fixed_t TexZ;
};
@ -458,6 +462,53 @@ struct sector_t
planes[pos].xform.base_angle = o;
}
int GetFlags(int pos) const
{
return planes[pos].Flags;
}
void ChangeFlags(int pos, int And, int Or)
{
planes[pos].Flags &= ~And;
planes[pos].Flags |= Or;
}
int GetPlaneLight(int pos) const
{
return planes[pos].Light;
}
void SetPlaneLight(int pos, int level)
{
planes[pos].Light = level;
}
FTextureID GetTexture(int pos) const
{
return planes[pos].Texture;
}
void SetTexture(int pos, FTextureID tex, bool floorclip = true)
{
FTextureID old = planes[pos].Texture;
planes[pos].Texture = tex;
if (floorclip && pos == floor && tex != old) AdjustFloorClip();
}
fixed_t GetPlaneTexZ(int pos) const
{
return planes[pos].TexZ;
}
void SetPlaneTexZ(int pos, fixed_t val)
{
planes[pos].TexZ = val;
}
void ChangePlaneTexZ(int pos, fixed_t val)
{
planes[pos].TexZ += val;
}
// Member variables
@ -466,14 +517,10 @@ struct sector_t
// [RH] store floor and ceiling planes instead of heights
secplane_t floorplane, ceilingplane;
fixed_t floortexz, ceilingtexz; // [RH] used for wall texture mapping
// [RH] give floor and ceiling even more properties
FDynamicColormap *ColorMap; // [RH] Per-sector colormap
BYTE FloorLight, CeilingLight;
BYTE FloorFlags, CeilingFlags;
FTextureID floorpic, ceilingpic;
BYTE lightlevel;
TObjPtr<AActor> SoundTarget;

17
src/r_interpolate.cpp
View file

@ -429,12 +429,12 @@ void DSectorPlaneInterpolation::UpdateInterpolation()
if (!ceiling)
{
oldheight = sector->floorplane.d;
oldtexz = sector->floortexz;
oldtexz = sector->GetPlaneTexZ(sector_t::floor);
}
else
{
oldheight = sector->ceilingplane.d;
oldtexz = sector->ceilingtexz;
oldtexz = sector->GetPlaneTexZ(sector_t::ceiling);
}
}
@ -449,12 +449,12 @@ void DSectorPlaneInterpolation::Restore()
if (!ceiling)
{
sector->floorplane.d = bakheight;
sector->floortexz = baktexz;
sector->SetPlaneTexZ(sector_t::floor, baktexz);
}
else
{
sector->ceilingplane.d = bakheight;
sector->ceilingtexz = baktexz;
sector->GetPlaneTexZ(sector_t::ceiling, baktexz?;
}
}
@ -467,24 +467,25 @@ void DSectorPlaneInterpolation::Restore()
void DSectorPlaneInterpolation::Interpolate(fixed_t smoothratio)
{
fixed_t *pheight;
int pos;
fixed_t *ptexz;
if (!ceiling)
{
pheight = &sector->floorplane.d;
ptexz = &sector->floortexz;
pos = sector_t::floor;
}
else
{
pheight = &sector->ceilingplane.d;
ptexz = &sector->ceilingtexz;
pos = sector_t::ceiling;
}
bakheight = *pheight;
baktexz = *ptexz;
baktexz = sector->GetPlaneTexZ(pos);
*pheight = oldheight + FixedMul(bakheight - oldheight, smoothratio);
*ptexz = oldtexz + FixedMul(baktexz - oldtexz, smoothratio);
sector->SetPlaneTexZ(pos, oldtexz + FixedMul(baktexz - oldtexz, smoothratio));
}
//==========================================================================

16
src/r_polymost.cpp
View file

@ -1267,8 +1267,8 @@ void RP_AddLine (seg_t *line)
solid = true;
}
else if (
(backsector->ceilingpic != skyflatnum ||
frontsector->ceilingpic != skyflatnum)
(backsector->GetTexture(sector_t::ceiling) != skyflatnum ||
frontsector->GetTexture(sector_t::ceiling) != skyflatnum)
// if door is closed because back is shut:
&& bcz0 <= bfz0 && bcz1 <= bfz1
@ -1296,8 +1296,8 @@ void RP_AddLine (seg_t *line)
solid = false;
}
else if (backsector->lightlevel != frontsector->lightlevel
|| backsector->floorpic != frontsector->floorpic
|| backsector->ceilingpic != frontsector->ceilingpic
|| backsector->GetTexture(sector_t::floor) != frontsector->GetTexture(sector_t::floor)
|| backsector->GetTexture(sector_t::ceiling) != frontsector->GetTexture(sector_t::ceiling)
|| curline->sidedef->GetTexture(side_t::mid).isValid()
// killough 3/7/98: Take flats offsets into account:
@ -1306,10 +1306,10 @@ void RP_AddLine (seg_t *line)
|| backsector->GetXOffset(sector_t::ceiling) != frontsector->GetXOffset(sector_t::ceiling)
|| backsector->GetYOffset(sector_t::ceiling) != frontsector->GetYOffset(sector_t::ceiling)
|| backsector->FloorLight != frontsector->FloorLight
|| backsector->CeilingLight != frontsector->CeilingLight
|| backsector->FloorFlags != frontsector->FloorFlags
|| backsector->CeilingFlags != frontsector->CeilingFlags
|| backsector->GetPlaneLight(sector_t::floor) != frontsector->GetPlaneLight(sector_t::floor)
|| backsector->GetPlaneLight(sector_t::ceiling) != frontsector->GetPlaneLight(sector_t::ceiling)
|| backsector->GetFlags(sector_t::floor) != frontsector->GetFlags(sector_t::floor)
|| backsector->GetFlags(sector_t::ceiling) != frontsector->GetFlags(sector_t::ceiling)
// [RH] Also consider colormaps
|| backsector->ColorMap != frontsector->ColorMap

56
src/r_segs.cpp
View file

@ -144,7 +144,7 @@ inline bool IsFogBoundary (sector_t *front, sector_t *back)
{
return r_fogboundary && !fixedcolormap && front->ColorMap->Fade &&
front->ColorMap->Fade != back->ColorMap->Fade &&
(front->ceilingpic != skyflatnum || back->ceilingpic != skyflatnum);
(front->GetTexture(sector_t::ceiling) != skyflatnum || back->GetTexture(sector_t::ceiling) != skyflatnum);
}
//=============================================================================
@ -255,11 +255,11 @@ void R_RenderMaskedSegRange (drawseg_t *ds, int x1, int x2)
texheight = tex->GetScaledHeight() << FRACBITS;
if (curline->linedef->flags & ML_DONTPEGBOTTOM)
{
dc_texturemid = MAX (frontsector->floortexz, backsector->floortexz) + texheight;
dc_texturemid = MAX (frontsector->GetPlaneTexZ(sector_t::floor), backsector->GetPlaneTexZ(sector_t::floor)) + texheight;
}
else
{
dc_texturemid = MIN (frontsector->ceilingtexz, backsector->ceilingtexz);
dc_texturemid = MIN (frontsector->GetPlaneTexZ(sector_t::ceiling), backsector->GetPlaneTexZ(sector_t::ceiling));
}
{ // encapsilate the lifetime of rowoffset
@ -1198,11 +1198,11 @@ void R_NewWall (bool needlights)
rowoffset = sidedef->GetTextureYOffset(side_t::mid);
if (linedef->flags & ML_DONTPEGBOTTOM)
{ // bottom of texture at bottom
rw_midtexturemid = frontsector->floortexz + (midtexture->GetHeight() << FRACBITS);
rw_midtexturemid = frontsector->GetPlaneTexZ(sector_t::floor) + (midtexture->GetHeight() << FRACBITS);
}
else
{ // top of texture at top
rw_midtexturemid = frontsector->ceilingtexz;
rw_midtexturemid = frontsector->GetPlaneTexZ(sector_t::ceiling);
if (rowoffset < 0 && midtexture != NULL)
{
rowoffset += midtexture->GetHeight() << FRACBITS;
@ -1230,10 +1230,10 @@ void R_NewWall (bool needlights)
{ // two-sided line
// hack to allow height changes in outdoor areas
rw_frontlowertop = frontsector->ceilingtexz;
rw_frontlowertop = frontsector->GetPlaneTexZ(sector_t::ceiling);
if (frontsector->ceilingpic == skyflatnum &&
backsector->ceilingpic == skyflatnum)
if (frontsector->GetTexture(sector_t::ceiling) == skyflatnum &&
backsector->GetTexture(sector_t::ceiling) == skyflatnum)
{
if (rw_havehigh)
{ // front ceiling is above back ceiling
@ -1251,7 +1251,7 @@ void R_NewWall (bool needlights)
}
// Putting sky ceilings on the front and back of a line alters the way unpegged
// positioning works.
rw_frontlowertop = backsector->ceilingtexz;
rw_frontlowertop = backsector->GetPlaneTexZ(sector_t::ceiling);
}
if ((rw_backcz1 <= rw_frontfz1 && rw_backcz2 <= rw_frontfz2) ||
@ -1265,7 +1265,7 @@ void R_NewWall (bool needlights)
markfloor = rw_mustmarkfloor
|| backsector->floorplane != frontsector->floorplane
|| backsector->lightlevel != frontsector->lightlevel
|| backsector->floorpic != frontsector->floorpic
|| backsector->GetTexture(sector_t::floor) != frontsector->GetTexture(sector_t::floor)
// killough 3/7/98: Add checks for (x,y) offsets
|| backsector->GetXOffset(sector_t::floor) != frontsector->GetXOffset(sector_t::floor)
@ -1275,8 +1275,8 @@ void R_NewWall (bool needlights)
// from bleeding through deep water
|| frontsector->heightsec
|| backsector->FloorLight != frontsector->FloorLight
|| backsector->FloorFlags != frontsector->FloorFlags
|| backsector->GetPlaneLight(sector_t::floor) != frontsector->GetPlaneLight(sector_t::floor)
|| backsector->GetFlags(sector_t::floor) != frontsector->GetFlags(sector_t::floor)
// [RH] Add checks for colormaps
|| backsector->ColorMap != frontsector->ColorMap
@ -1289,12 +1289,12 @@ void R_NewWall (bool needlights)
|| (sidedef->GetTexture(side_t::mid).isValid() && linedef->flags & (ML_CLIP_MIDTEX|ML_WRAP_MIDTEX))
;
markceiling = (frontsector->ceilingpic != skyflatnum ||
backsector->ceilingpic != skyflatnum) &&
markceiling = (frontsector->GetTexture(sector_t::ceiling) != skyflatnum ||
backsector->GetTexture(sector_t::ceiling) != skyflatnum) &&
(rw_mustmarkceiling
|| backsector->ceilingplane != frontsector->ceilingplane
|| backsector->lightlevel != frontsector->lightlevel
|| backsector->ceilingpic != frontsector->ceilingpic
|| backsector->GetTexture(sector_t::ceiling) != frontsector->GetTexture(sector_t::ceiling)
// killough 3/7/98: Add checks for (x,y) offsets
|| backsector->GetXOffset(sector_t::ceiling) != frontsector->GetXOffset(sector_t::ceiling)
@ -1302,10 +1302,10 @@ void R_NewWall (bool needlights)
// killough 4/15/98: prevent 2s normals
// from bleeding through fake ceilings
|| (frontsector->heightsec && frontsector->ceilingpic != skyflatnum)
|| (frontsector->heightsec && frontsector->GetTexture(sector_t::ceiling) != skyflatnum)
|| backsector->CeilingLight != frontsector->CeilingLight
|| backsector->CeilingFlags != frontsector->CeilingFlags
|| backsector->GetPlaneLight(sector_t::ceiling) != frontsector->GetPlaneLight(sector_t::ceiling)
|| backsector->GetFlags(sector_t::ceiling) != frontsector->GetFlags(sector_t::ceiling)
// [RH] Add check for colormaps
|| backsector->ColorMap != frontsector->ColorMap
@ -1328,7 +1328,7 @@ void R_NewWall (bool needlights)
rowoffset = sidedef->GetTextureYOffset(side_t::top);
if (linedef->flags & ML_DONTPEGTOP)
{ // top of texture at top
rw_toptexturemid = MulScale16 (frontsector->ceilingtexz - viewz, scale);
rw_toptexturemid = MulScale16 (frontsector->GetPlaneTexZ(sector_t::ceiling) - viewz, scale);
if (rowoffset < 0 && toptexture != NULL)
{
rowoffset += toptexture->GetHeight() << FRACBITS;
@ -1336,7 +1336,7 @@ void R_NewWall (bool needlights)
}
else
{ // bottom of texture at bottom
rw_toptexturemid = MulScale16 (backsector->ceilingtexz - viewz, scale) + (toptexture->GetHeight() << FRACBITS);
rw_toptexturemid = MulScale16 (backsector->GetPlaneTexZ(sector_t::ceiling) - viewz, scale) + (toptexture->GetHeight() << FRACBITS);
}
if (toptexture->bWorldPanning)
{
@ -1359,7 +1359,7 @@ void R_NewWall (bool needlights)
}
else
{ // top of texture at top
rw_bottomtexturemid = backsector->floortexz;
rw_bottomtexturemid = backsector->GetPlaneTexZ(sector_t::floor);
if (rowoffset < 0 && bottomtexture != NULL)
{
rowoffset += bottomtexture->GetHeight() << FRACBITS;
@ -1388,7 +1388,7 @@ void R_NewWall (bool needlights)
if (frontsector->floorplane.ZatPoint (viewx, viewy) >= viewz) // above view plane
markfloor = false;
if (frontsector->ceilingplane.ZatPoint (viewx, viewy) <= viewz &&
frontsector->ceilingpic != skyflatnum) // below view plane
frontsector->GetTexture(sector_t::ceiling) != skyflatnum) // below view plane
markceiling = false;
}
@ -2145,31 +2145,31 @@ static void R_RenderDecal (side_t *wall, DBaseDecal *decal, drawseg_t *clipper,
case RF_RELUPPER:
if (curline->linedef->flags & ML_DONTPEGTOP)
{
zpos = decal->Z + front->ceilingtexz;
zpos = decal->Z + front->GetPlaneTexZ(sector_t::ceiling);
}
else
{
zpos = decal->Z + back->ceilingtexz;
zpos = decal->Z + back->GetPlaneTexZ(sector_t::ceiling);
}
break;
case RF_RELLOWER:
if (curline->linedef->flags & ML_DONTPEGBOTTOM)
{
zpos = decal->Z + front->ceilingtexz;
zpos = decal->Z + front->GetPlaneTexZ(sector_t::ceiling);
}
else
{
zpos = decal->Z + back->floortexz;
zpos = decal->Z + back->GetPlaneTexZ(sector_t::floor);
}
break;
case RF_RELMID:
if (curline->linedef->flags & ML_DONTPEGBOTTOM)
{
zpos = decal->Z + front->floortexz;
zpos = decal->Z + front->GetPlaneTexZ(sector_t::floor);
}
else
{
zpos = decal->Z + front->ceilingtexz;
zpos = decal->Z + front->GetPlaneTexZ(sector_t::ceiling);
}
}

16
src/r_things.cpp
View file

@ -2381,24 +2381,24 @@ void R_ProjectParticle (particle_t *particle, const sector_t *sector, int shade,
{
topplane = &sector->ceilingplane;
botplane = &heightsec->ceilingplane;
toppic = sector->ceilingpic;
botpic = heightsec->ceilingpic;
toppic = sector->GetTexture(sector_t::ceiling);
botpic = heightsec->GetTexture(sector_t::ceiling);
map = heightsec->ColorMap->Maps;
}
else if (fakeside == FAKED_BelowFloor)
{
topplane = &heightsec->floorplane;
botplane = &sector->floorplane;
toppic = heightsec->floorpic;
botpic = sector->floorpic;
toppic = heightsec->GetTexture(sector_t::floor);
botpic = sector->GetTexture(sector_t::floor);
map = heightsec->ColorMap->Maps;
}
else
{
topplane = &heightsec->ceilingplane;
botplane = &heightsec->floorplane;
toppic = heightsec->ceilingpic;
botpic = heightsec->floorpic;
toppic = heightsec->GetTexture(sector_t::ceiling);
botpic = heightsec->GetTexture(sector_t::floor);
map = sector->ColorMap->Maps;
}
}
@ -2406,8 +2406,8 @@ void R_ProjectParticle (particle_t *particle, const sector_t *sector, int shade,
{
topplane = &sector->ceilingplane;
botplane = &sector->floorplane;
toppic = sector->ceilingpic;
botpic = sector->floorpic;
toppic = sector->GetTexture(sector_t::ceiling);
botpic = sector->GetTexture(sector_t::floor);
map = sector->ColorMap->Maps;
}