stjr/SRB2
0
0
Fork 0
mirror of https://git.do.srb2.org/STJr/SRB2.git synced 2024-11-15 01:01:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'udmf-texture-scaling' into 'next'

Browse source 
Wall texture scaling

See merge request STJr/SRB2!2031
This commit is contained in:
sphere 2023-12-11 22:14:41 +00:00
commit c4526bc777
6 changed files with 676 additions and 370 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

232
src/hardware/hw_main.c
View file

@ -1081,6 +1081,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
fixed_t h, l; // 3D sides and 2s middle textures
fixed_t hS, lS;
float xscale, yscale;
gl_sidedef = gl_curline->sidedef;
gl_linedef = gl_curline->linedef;
@ -1179,47 +1180,53 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
// check TOP TEXTURE
if ((worldhighslope < worldtopslope || worldhigh < worldtop) && gl_toptexture)
{
grTex = HWR_GetTexture(gl_toptexture);
xscale = FixedToFloat(gl_sidedef->scalex_top);
yscale = FixedToFloat(gl_sidedef->scaley_top);
fixed_t texheight = FixedDiv(textureheight[gl_toptexture], gl_sidedef->scaley_top);
// PEGGING
if (gl_linedef->flags & ML_DONTPEGTOP)
texturevpeg = 0;
else if (gl_linedef->flags & ML_SKEWTD)
texturevpeg = worldhigh + textureheight[gl_toptexture] - worldtop;
texturevpeg = worldhigh + texheight - worldtop;
else
texturevpeg = gl_backsector->ceilingheight + textureheight[gl_toptexture] - gl_frontsector->ceilingheight;
texturevpeg = gl_backsector->ceilingheight + texheight - gl_frontsector->ceilingheight;
texturevpeg *= yscale;
texturevpeg += gl_sidedef->rowoffset + gl_sidedef->offsety_top;
// This is so that it doesn't overflow and screw up the wall, it doesn't need to go higher than the texture's height anyway
texturevpeg %= textureheight[gl_toptexture];
grTex = HWR_GetTexture(gl_toptexture);
texturevpeg %= texheight;
wallVerts[3].t = wallVerts[2].t = texturevpeg * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (texturevpeg + gl_frontsector->ceilingheight - gl_backsector->ceilingheight) * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = (cliplow + gl_sidedef->offsetx_top) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = (cliphigh + gl_sidedef->offsetx_top) * grTex->scaleX;
wallVerts[0].t = wallVerts[1].t = (texturevpeg + (gl_frontsector->ceilingheight - gl_backsector->ceilingheight) * yscale) * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + gl_sidedef->offsetx_top) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + gl_sidedef->offsetx_top) * grTex->scaleX;
// Adjust t value for sloped walls
if (!(gl_linedef->flags & ML_SKEWTD))
{
// Unskewed
wallVerts[3].t -= (worldtop - gl_frontsector->ceilingheight) * grTex->scaleY;
wallVerts[2].t -= (worldtopslope - gl_frontsector->ceilingheight) * grTex->scaleY;
wallVerts[0].t -= (worldhigh - gl_backsector->ceilingheight) * grTex->scaleY;
wallVerts[1].t -= (worldhighslope - gl_backsector->ceilingheight) * grTex->scaleY;
wallVerts[3].t -= (worldtop - gl_frontsector->ceilingheight) * yscale * grTex->scaleY;
wallVerts[2].t -= (worldtopslope - gl_frontsector->ceilingheight) * yscale * grTex->scaleY;
wallVerts[0].t -= (worldhigh - gl_backsector->ceilingheight) * yscale * grTex->scaleY;
wallVerts[1].t -= (worldhighslope - gl_backsector->ceilingheight) * yscale * grTex->scaleY;
}
else if (gl_linedef->flags & ML_DONTPEGTOP)
{
// Skewed by top
wallVerts[0].t = (texturevpeg + worldtop - worldhigh) * grTex->scaleY;
wallVerts[1].t = (texturevpeg + worldtopslope - worldhighslope) * grTex->scaleY;
wallVerts[0].t = (texturevpeg + (worldtop - worldhigh) * yscale) * grTex->scaleY;
wallVerts[1].t = (texturevpeg + (worldtopslope - worldhighslope) * yscale) * grTex->scaleY;
}
else
{
// Skewed by bottom
wallVerts[0].t = wallVerts[1].t = (texturevpeg + worldtop - worldhigh) * grTex->scaleY;
wallVerts[3].t = wallVerts[0].t - (worldtop - worldhigh) * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t - (worldtopslope - worldhighslope) * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (texturevpeg + (worldtop - worldhigh) * yscale) * grTex->scaleY;
wallVerts[3].t = wallVerts[0].t - (worldtop - worldhigh) * yscale * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t - (worldtopslope - worldhighslope) * yscale * grTex->scaleY;
}
// set top/bottom coords
@ -1239,6 +1246,10 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
// check BOTTOM TEXTURE
if ((worldlowslope > worldbottomslope || worldlow > worldbottom) && gl_bottomtexture)
{
grTex = HWR_GetTexture(gl_bottomtexture);
xscale = FixedToFloat(gl_sidedef->scalex_bottom);
yscale = FixedToFloat(gl_sidedef->scaley_bottom);
// PEGGING
if (!(gl_linedef->flags & ML_DONTPEGBOTTOM))
texturevpeg = 0;
@ -1247,38 +1258,38 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
else
texturevpeg = gl_frontsector->floorheight - gl_backsector->floorheight;
texturevpeg += gl_sidedef->rowoffset + gl_sidedef->offsety_bot;
texturevpeg *= yscale;
texturevpeg += gl_sidedef->rowoffset + gl_sidedef->offsety_bottom;
// This is so that it doesn't overflow and screw up the wall, it doesn't need to go higher than the texture's height anyway
texturevpeg %= textureheight[gl_bottomtexture];
grTex = HWR_GetTexture(gl_bottomtexture);
texturevpeg %= FixedDiv(textureheight[gl_bottomtexture], gl_sidedef->scaley_bottom);
wallVerts[3].t = wallVerts[2].t = texturevpeg * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (texturevpeg + gl_backsector->floorheight - gl_frontsector->floorheight) * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = (cliplow + gl_sidedef->offsetx_bot) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = (cliphigh + gl_sidedef->offsetx_bot) * grTex->scaleX;
wallVerts[0].t = wallVerts[1].t = (texturevpeg + (gl_backsector->floorheight - gl_frontsector->floorheight) * yscale) * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + gl_sidedef->offsetx_bottom) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + gl_sidedef->offsetx_bottom) * grTex->scaleX;
// Adjust t value for sloped walls
if (!(gl_linedef->flags & ML_SKEWTD))
{
// Unskewed
wallVerts[0].t -= (worldbottom - gl_frontsector->floorheight) * grTex->scaleY;
wallVerts[1].t -= (worldbottomslope - gl_frontsector->floorheight) * grTex->scaleY;
wallVerts[3].t -= (worldlow - gl_backsector->floorheight) * grTex->scaleY;
wallVerts[2].t -= (worldlowslope - gl_backsector->floorheight) * grTex->scaleY;
wallVerts[0].t -= (worldbottom - gl_frontsector->floorheight) * yscale * grTex->scaleY;
wallVerts[1].t -= (worldbottomslope - gl_frontsector->floorheight) * yscale * grTex->scaleY;
wallVerts[3].t -= (worldlow - gl_backsector->floorheight) * yscale * grTex->scaleY;
wallVerts[2].t -= (worldlowslope - gl_backsector->floorheight) * yscale * grTex->scaleY;
}
else if (gl_linedef->flags & ML_DONTPEGBOTTOM)
{
// Skewed by bottom
wallVerts[0].t = wallVerts[1].t = (texturevpeg + worldlow - worldbottom) * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t - (worldlowslope - worldbottomslope) * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (texturevpeg + (worldlow - worldbottom) * yscale) * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t - (worldlowslope - worldbottomslope) * yscale * grTex->scaleY;
}
else
{
// Skewed by top
wallVerts[0].t = (texturevpeg + worldlow - worldbottom) * grTex->scaleY;
wallVerts[1].t = (texturevpeg + worldlowslope - worldbottomslope) * grTex->scaleY;
wallVerts[0].t = (texturevpeg + (worldlow - worldbottom) * yscale) * grTex->scaleY;
wallVerts[1].t = (texturevpeg + (worldlowslope - worldbottomslope) * yscale) * grTex->scaleY;
}
// set top/bottom coords
@ -1299,6 +1310,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if (gl_midtexture && HWR_BlendMidtextureSurface(&Surf))
{
sector_t *front, *back;
fixed_t texheight = FixedDiv(textureheight[gl_midtexture], gl_sidedef->scaley_mid);
INT32 repeats;
if (gl_linedef->frontsector->heightsec != -1)
@ -1327,13 +1339,17 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
else
low = back->floorheight;
repeats = (high - low) / textureheight[gl_midtexture];
if ((high - low) % textureheight[gl_midtexture])
repeats = (high - low) / texheight;
if ((high - low) % texheight)
repeats++; // tile an extra time to fill the gap -- Monster Iestyn
}
else
repeats = 1;
grTex = HWR_GetTexture(gl_midtexture);
xscale = FixedToFloat(gl_sidedef->scalex_mid);
yscale = FixedToFloat(gl_sidedef->scaley_mid);
// SoM: a little note: popentop and popenbottom
// record the limits the texture can be displayed in.
// polytop and polybottom, are the ideal (i.e. unclipped)
@ -1351,7 +1367,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
popenbottom = popenbottomslope = back->floorheight;
}
else
{
{
popentop = min(worldtop, worldhigh);
popenbottom = max(worldbottom, worldlow);
popentopslope = min(worldtopslope, worldhighslope);
@ -1359,7 +1375,9 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
}
// Find the wall's coordinates
fixed_t midtexheight = textureheight[gl_midtexture] * repeats;
fixed_t midtexheight = texheight * repeats;
fixed_t rowoffset = FixedDiv(gl_sidedef->rowoffset + gl_sidedef->offsety_mid, gl_sidedef->scaley_mid);
// Texture is not skewed
if (gl_linedef->flags & ML_NOSKEW)
@ -1367,13 +1385,13 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
// Peg it to the floor
if (gl_linedef->flags & ML_MIDPEG)
{
polybottom = max(front->floorheight, back->floorheight) + gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
polybottom = max(front->floorheight, back->floorheight) + rowoffset;
polytop = polybottom + midtexheight;
}
// Peg it to the ceiling
else
{
polytop = min(front->ceilingheight, back->ceilingheight) + gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
polytop = min(front->ceilingheight, back->ceilingheight) + rowoffset;
polybottom = polytop - midtexheight;
}
@ -1384,17 +1402,17 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
// Skew the texture, but peg it to the floor
else if (gl_linedef->flags & ML_MIDPEG)
{
polybottom = popenbottom + gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
polybottom = popenbottom + rowoffset;
polytop = polybottom + midtexheight;
polybottomslope = popenbottomslope + gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
polybottomslope = popenbottomslope + rowoffset;
polytopslope = polybottomslope + midtexheight;
}
// Skew it according to the ceiling's slope
else
{
polytop = popentop + gl_sidedef->rowoffset;
polytop = popentop + rowoffset;
polybottom = polytop - midtexheight;
polytopslope = popentopslope + gl_sidedef->rowoffset;
polytopslope = popentopslope + rowoffset;
polybottomslope = polytopslope - midtexheight;
}
@ -1436,17 +1454,15 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
texturevpegslope = polytopslope - hS;
}
grTex = HWR_GetTexture(gl_midtexture);
// Left side
wallVerts[3].t = texturevpeg * grTex->scaleY;
wallVerts[0].t = (h - l + texturevpeg) * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = (cliplow + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[3].t = texturevpeg * yscale * grTex->scaleY;
wallVerts[0].t = (h - l + texturevpeg) * yscale * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + gl_sidedef->offsetx_mid) * grTex->scaleX;
// Right side
wallVerts[2].t = texturevpegslope * grTex->scaleY;
wallVerts[1].t = (hS - lS + texturevpegslope) * grTex->scaleY;
wallVerts[2].s = wallVerts[1].s = (cliphigh + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[2].t = texturevpegslope * yscale * grTex->scaleY;
wallVerts[1].t = (hS - lS + texturevpegslope) * yscale * grTex->scaleY;
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + gl_sidedef->offsetx_mid) * grTex->scaleX;
// set top/bottom coords
// Take the texture peg into account, rather than changing the offsets past
@ -1504,36 +1520,40 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
// Single sided line... Deal only with the middletexture (if one exists)
if (gl_midtexture && gl_linedef->special != HORIZONSPECIAL) // (Ignore horizon line for OGL)
{
grTex = HWR_GetTexture(gl_midtexture);
xscale = FixedToFloat(gl_sidedef->scalex_mid);
yscale = FixedToFloat(gl_sidedef->scaley_mid);
fixed_t texturevpeg;
// PEGGING
if ((gl_linedef->flags & (ML_DONTPEGBOTTOM|ML_NOSKEW)) == (ML_DONTPEGBOTTOM|ML_NOSKEW))
texturevpeg = gl_frontsector->floorheight + textureheight[gl_sidedef->midtexture] - gl_frontsector->ceilingheight + gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
texturevpeg = (gl_frontsector->floorheight + textureheight[gl_sidedef->midtexture] - gl_frontsector->ceilingheight) * yscale;
else if (gl_linedef->flags & ML_DONTPEGBOTTOM)
texturevpeg = worldbottom + textureheight[gl_sidedef->midtexture] - worldtop + gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
texturevpeg = (worldbottom + textureheight[gl_sidedef->midtexture] - worldtop) * yscale;
else
// top of texture at top
texturevpeg = gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
texturevpeg = 0;
grTex = HWR_GetTexture(gl_midtexture);
texturevpeg += gl_sidedef->rowoffset + gl_sidedef->offsety_mid;
wallVerts[3].t = wallVerts[2].t = texturevpeg * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (texturevpeg + gl_frontsector->ceilingheight - gl_frontsector->floorheight) * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = (cliplow + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = (cliphigh + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + gl_sidedef->offsetx_mid) * grTex->scaleX;
// Texture correction for slopes
if (gl_linedef->flags & ML_NOSKEW) {
wallVerts[3].t += (gl_frontsector->ceilingheight - worldtop) * grTex->scaleY;
wallVerts[2].t += (gl_frontsector->ceilingheight - worldtopslope) * grTex->scaleY;
wallVerts[0].t += (gl_frontsector->floorheight - worldbottom) * grTex->scaleY;
wallVerts[1].t += (gl_frontsector->floorheight - worldbottomslope) * grTex->scaleY;
wallVerts[3].t += (gl_frontsector->ceilingheight - worldtop) * yscale * grTex->scaleY;
wallVerts[2].t += (gl_frontsector->ceilingheight - worldtopslope) * yscale * grTex->scaleY;
wallVerts[0].t += (gl_frontsector->floorheight - worldbottom) * yscale * grTex->scaleY;
wallVerts[1].t += (gl_frontsector->floorheight - worldbottomslope) * yscale * yscale;
} else if (gl_linedef->flags & ML_DONTPEGBOTTOM) {
wallVerts[3].t = wallVerts[0].t + (worldbottom-worldtop) * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t + (worldbottomslope-worldtopslope) * grTex->scaleY;
wallVerts[3].t = wallVerts[0].t + ((worldbottom - worldtop) * yscale) * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t + ((worldbottomslope - worldtopslope) * yscale) * grTex->scaleY;
} else {
wallVerts[0].t = wallVerts[3].t - (worldbottom-worldtop) * grTex->scaleY;
wallVerts[1].t = wallVerts[2].t - (worldbottomslope-worldtopslope) * grTex->scaleY;
wallVerts[0].t = wallVerts[3].t - ((worldbottom - worldtop) * yscale) * grTex->scaleY;
wallVerts[1].t = wallVerts[2].t - ((worldbottomslope - worldtopslope) * yscale) * grTex->scaleY;
}
//Set textures properly on single sided walls that are sloped
@ -1618,15 +1638,17 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if ((high1 < lowcut && highslope1 < lowcutslope) || (low1 > highcut && lowslope1 > highcutslope))
continue;
texnum = R_GetTextureNum(sides[rover->master->sidenum[0]].midtexture);
side_t *side = &sides[rover->master->sidenum[0]];
if (rover->master->flags & ML_TFERLINE)
{
size_t linenum = gl_curline->linedef-gl_backsector->lines[0];
newline = rover->master->frontsector->lines[0] + linenum;
texnum = R_GetTextureNum(sides[newline->sidenum[0]].midtexture);
side = &sides[newline->sidenum[0]];
}
texnum = R_GetTextureNum(side->midtexture);
h = P_GetFFloorTopZAt (rover, v1x, v1y);
hS = P_GetFFloorTopZAt (rover, v2x, v2y);
l = P_GetFFloorBottomZAt(rover, v1x, v1y);
@ -1642,14 +1664,13 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
l = lowcut;
lS = lowcutslope;
}
//Hurdler: HW code starts here
//FIXME: check if peging is correct
// set top/bottom coords
// set top/bottom coords
wallVerts[3].y = FIXED_TO_FLOAT(h);
wallVerts[2].y = FIXED_TO_FLOAT(hS);
wallVerts[0].y = FIXED_TO_FLOAT(l);
wallVerts[1].y = FIXED_TO_FLOAT(lS);
if (rover->fofflags & FOF_FOG)
{
wallVerts[3].t = wallVerts[2].t = 0;
@ -1659,56 +1680,46 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
}
else
{
fixed_t texturevpeg;
boolean attachtobottom = false;
boolean slopeskew = false; // skew FOF walls with slopes?
// Wow, how was this missing from OpenGL for so long?
// ...Oh well, anyway, Lower Unpegged now changes pegging of FOFs like in software
// -- Monster Iestyn 26/06/18
if (newline)
{
texturevpeg = sides[newline->sidenum[0]].rowoffset + sides[newline->sidenum[0]].offsety_mid;
attachtobottom = !!(newline->flags & ML_DONTPEGBOTTOM);
slopeskew = !!(newline->flags & ML_SKEWTD);
}
else
{
texturevpeg = sides[rover->master->sidenum[0]].rowoffset + sides[rover->master->sidenum[0]].offsety_mid;
attachtobottom = !!(gl_linedef->flags & ML_DONTPEGBOTTOM);
slopeskew = !!(rover->master->flags & ML_SKEWTD);
}
fixed_t texturevpeg = side->rowoffset + side->offsety_mid;
boolean attachtobottom = !!(rover->master->flags & ML_DONTPEGBOTTOM);
grTex = HWR_GetTexture(texnum);
xscale = FixedToFloat(side->scalex_mid);
yscale = FixedToFloat(side->scaley_mid);
if (!slopeskew) // no skewing
if (!(rover->master->flags & ML_SKEWTD)) // no skewing
{
if (attachtobottom)
texturevpeg -= *rover->topheight - *rover->bottomheight;
wallVerts[3].t = (*rover->topheight - h + texturevpeg) * grTex->scaleY;
wallVerts[2].t = (*rover->topheight - hS + texturevpeg) * grTex->scaleY;
wallVerts[0].t = (*rover->topheight - l + texturevpeg) * grTex->scaleY;
wallVerts[1].t = (*rover->topheight - lS + texturevpeg) * grTex->scaleY;
texturevpeg -= (*rover->topheight - *rover->bottomheight) * yscale;
wallVerts[3].t = (((*rover->topheight - h) * yscale) + texturevpeg) * grTex->scaleY;
wallVerts[2].t = (((*rover->topheight - hS) * yscale) + texturevpeg) * grTex->scaleY;
wallVerts[0].t = (((*rover->topheight - l) * yscale) + texturevpeg) * grTex->scaleY;
wallVerts[1].t = (((*rover->topheight - lS) * yscale) + texturevpeg) * grTex->scaleY;
}
else
{
if (!attachtobottom) // skew by top
{
wallVerts[3].t = wallVerts[2].t = texturevpeg * grTex->scaleY;
wallVerts[0].t = (h - l + texturevpeg) * grTex->scaleY;
wallVerts[1].t = (hS - lS + texturevpeg) * grTex->scaleY;
wallVerts[0].t = (((h - l) * yscale) + texturevpeg) * grTex->scaleY;
wallVerts[1].t = (((hS - lS) * yscale) + texturevpeg) * grTex->scaleY;
}
else // skew by bottom
{
wallVerts[0].t = wallVerts[1].t = texturevpeg * grTex->scaleY;
wallVerts[3].t = wallVerts[0].t - (h - l) * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t - (hS - lS) * grTex->scaleY;
wallVerts[3].t = wallVerts[0].t - ((h - l) * yscale) * grTex->scaleY;
wallVerts[2].t = wallVerts[1].t - ((hS - lS) * yscale) * grTex->scaleY;
}
}
wallVerts[0].s = wallVerts[3].s = (cliplow + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = (cliphigh + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + side->offsetx_mid) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + side->offsetx_mid) * grTex->scaleX;
}
if (rover->fofflags & FOF_FOG)
{
FBITFIELD blendmode;
@ -1775,14 +1786,17 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if ((high1 < lowcut && highslope1 < lowcutslope) || (low1 > highcut && lowslope1 > highcutslope))
continue;
texnum = R_GetTextureNum(sides[rover->master->sidenum[0]].midtexture);
side_t *side = &sides[rover->master->sidenum[0]];
if (rover->master->flags & ML_TFERLINE)
{
size_t linenum = gl_curline->linedef-gl_backsector->lines[0];
newline = rover->master->frontsector->lines[0] + linenum;
texnum = R_GetTextureNum(sides[newline->sidenum[0]].midtexture);
side = &sides[newline->sidenum[0]];
}
texnum = R_GetTextureNum(side->midtexture);
h = P_GetFFloorTopZAt (rover, v1x, v1y);
hS = P_GetFFloorTopZAt (rover, v2x, v2y);
l = P_GetFFloorBottomZAt(rover, v1x, v1y);
@ -1816,20 +1830,16 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
else
{
grTex = HWR_GetTexture(texnum);
xscale = FixedToFloat(side->scalex_mid);
yscale = FixedToFloat(side->scaley_mid);
if (newline)
{
wallVerts[3].t = wallVerts[2].t = (*rover->topheight - h + sides[newline->sidenum[0]].rowoffset + sides[newline->sidenum[0]].offsety_mid) * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (h - l + (*rover->topheight - h + sides[newline->sidenum[0]].rowoffset) + sides[newline->sidenum[0]].offsety_mid) * grTex->scaleY;
}
else
{
wallVerts[3].t = wallVerts[2].t = (*rover->topheight - h + sides[rover->master->sidenum[0]].rowoffset + sides[rover->master->sidenum[0]].offsety_mid) * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (h - l + (*rover->topheight - h + sides[rover->master->sidenum[0]].rowoffset + sides[rover->master->sidenum[0]].offsety_mid)) * grTex->scaleY;
}
fixed_t diff = (*rover->topheight - h) * yscale;
wallVerts[0].s = wallVerts[3].s = (cliplow + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = (cliphigh + gl_sidedef->offsetx_mid) * grTex->scaleX;
wallVerts[3].t = wallVerts[2].t = (diff + side->rowoffset + side->offsety_mid) * grTex->scaleY;
wallVerts[0].t = wallVerts[1].t = (((h - l) * yscale) + (diff + side->rowoffset + side->offsety_mid)) * grTex->scaleY;
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + side->offsetx_mid) * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + side->offsetx_mid) * grTex->scaleX;
}
if (rover->fofflags & FOF_FOG)

56
src/lua_maplib.c
View file

@ -190,6 +190,12 @@ enum side_e {
side_offsety_mid,
side_offsetx_bot,
side_offsety_bot,
side_scalex_top,
side_scaley_top,
side_scalex_mid,
side_scaley_mid,
side_scalex_bot,
side_scaley_bot,
side_toptexture,
side_bottomtexture,
side_midtexture,
@ -210,6 +216,12 @@ static const char *const side_opt[] = {
"offsety_mid",
"offsetx_bot",
"offsety_bot",
"scalex_top",
"scaley_top",
"scalex_mid",
"scaley_mid",
"scalex_bot",
"scaley_bot",
"toptexture",
"bottomtexture",
"midtexture",
@ -1211,10 +1223,28 @@ static int side_get(lua_State *L)
lua_pushfixed(L, side->offsety_mid);
return 1;
case side_offsetx_bot:
lua_pushfixed(L, side->offsetx_bot);
lua_pushfixed(L, side->offsetx_bottom);
return 1;
case side_offsety_bot:
lua_pushfixed(L, side->offsety_bot);
lua_pushfixed(L, side->offsety_bottom);
return 1;
case side_scalex_top:
lua_pushfixed(L, side->scalex_top);
return 1;
case side_scaley_top:
lua_pushfixed(L, side->scaley_top);
return 1;
case side_scalex_mid:
lua_pushfixed(L, side->scalex_mid);
return 1;
case side_scaley_mid:
lua_pushfixed(L, side->scaley_mid);
return 1;
case side_scalex_bot:
lua_pushfixed(L, side->scalex_bottom);
return 1;
case side_scaley_bot:
lua_pushfixed(L, side->scaley_bottom);
return 1;
case side_toptexture:
lua_pushinteger(L, side->toptexture);
@ -1302,10 +1332,28 @@ static int side_set(lua_State *L)
side->offsety_mid = luaL_checkfixed(L, 3);
break;
case side_offsetx_bot:
side->offsetx_bot = luaL_checkfixed(L, 3);
side->offsetx_bottom = luaL_checkfixed(L, 3);
break;
case side_offsety_bot:
side->offsety_bot = luaL_checkfixed(L, 3);
side->offsety_bottom = luaL_checkfixed(L, 3);
break;
case side_scalex_top:
side->scalex_top = luaL_checkfixed(L, 3);
break;
case side_scaley_top:
side->scaley_top = luaL_checkfixed(L, 3);
break;
case side_scalex_mid:
side->scalex_mid = luaL_checkfixed(L, 3);
break;
case side_scaley_mid:
side->scaley_mid = luaL_checkfixed(L, 3);
break;
case side_scalex_bot:
side->scalex_bottom = luaL_checkfixed(L, 3);
break;
case side_scaley_bot:
side->scaley_bottom = luaL_checkfixed(L, 3);
break;
case side_toptexture:
side->toptexture = luaL_checkinteger(L, 3);

293
src/p_saveg.c
View file

@ -868,23 +868,42 @@ static void P_NetUnArchiveWaypoints(void)
#define SD_TRIGGERER 0x04
#define SD_GRAVITY 0x08
#define LD_FLAG 0x01
#define LD_SPECIAL 0x02
#define LD_CLLCOUNT 0x04
#define LD_S1TEXOFF 0x08
#define LD_S1TOPTEX 0x10
#define LD_S1BOTTEX 0x20
#define LD_S1MIDTEX 0x40
#define LD_DIFF2 0x80
#define LD_FLAG 0x01
#define LD_SPECIAL 0x02
#define LD_CLLCOUNT 0x04
#define LD_ARGS 0x08
#define LD_STRINGARGS 0x10
#define LD_EXECUTORDELAY 0x20
#define LD_SIDE1 0x40
#define LD_SIDE2 0x80
// diff2 flags
#define LD_S2TEXOFF 0x01
#define LD_S2TOPTEX 0x02
#define LD_S2BOTTEX 0x04
#define LD_S2MIDTEX 0x08
#define LD_ARGS 0x10
#define LD_STRINGARGS 0x20
#define LD_EXECUTORDELAY 0x40
// sidedef flags
enum
{
LD_SDTEXOFFX = 1,
LD_SDTEXOFFY = 1<<1,
LD_SDTOPTEX = 1<<2,
LD_SDBOTTEX = 1<<3,
LD_SDMIDTEX = 1<<4,
LD_SDTOPOFFX = 1<<5,
LD_SDTOPOFFY = 1<<6,
LD_SDMIDOFFX = 1<<7,
LD_SDMIDOFFY = 1<<8,
LD_SDBOTOFFX = 1<<9,
LD_SDBOTOFFY = 1<<10,
LD_SDTOPSCALEX = 1<<11,
LD_SDTOPSCALEY = 1<<12,
LD_SDMIDSCALEX = 1<<13,
LD_SDMIDSCALEY = 1<<14,
LD_SDBOTSCALEX = 1<<15,
LD_SDBOTSCALEY = 1<<16,
LD_SDLIGHT = 1<<17,
LD_SDTOPLIGHT = 1<<18,
LD_SDMIDLIGHT = 1<<19,
LD_SDBOTLIGHT = 1<<20,
LD_SDREPEATCNT = 1<<21,
LD_SDFLAGS = 1<<22
};
static boolean P_AreArgsEqual(const line_t *li, const line_t *spawnli)
{
@ -1272,18 +1291,103 @@ static void UnArchiveSectors(void)
}
}
static UINT32 GetSideDiff(const side_t *si, const side_t *spawnsi)
{
UINT32 diff = 0;
if (si->textureoffset != spawnsi->textureoffset)
diff |= LD_SDTEXOFFX;
if (si->rowoffset != spawnsi->rowoffset)
diff |= LD_SDTEXOFFY;
//SoM: 4/1/2000: Some textures are colormaps. Don't worry about invalid textures.
if (si->toptexture != spawnsi->toptexture)
diff |= LD_SDTOPTEX;
if (si->bottomtexture != spawnsi->bottomtexture)
diff |= LD_SDBOTTEX;
if (si->midtexture != spawnsi->midtexture)
diff |= LD_SDMIDTEX;
if (si->offsetx_top != spawnsi->offsetx_top)
diff |= LD_SDTOPOFFX;
if (si->offsetx_mid != spawnsi->offsetx_mid)
diff |= LD_SDMIDOFFX;
if (si->offsetx_bottom != spawnsi->offsetx_bottom)
diff |= LD_SDBOTOFFX;
if (si->offsety_top != spawnsi->offsety_top)
diff |= LD_SDTOPOFFY;
if (si->offsety_mid != spawnsi->offsety_mid)
diff |= LD_SDMIDOFFY;
if (si->offsety_bottom != spawnsi->offsety_bottom)
diff |= LD_SDBOTOFFY;
if (si->scalex_top != spawnsi->scalex_top)
diff |= LD_SDTOPSCALEX;
if (si->scalex_mid != spawnsi->scalex_mid)
diff |= LD_SDMIDSCALEX;
if (si->scalex_bottom != spawnsi->scalex_bottom)
diff |= LD_SDBOTSCALEX;
if (si->scaley_top != spawnsi->scaley_top)
diff |= LD_SDTOPSCALEY;
if (si->scaley_mid != spawnsi->scaley_mid)
diff |= LD_SDMIDSCALEY;
if (si->scaley_bottom != spawnsi->scaley_bottom)
diff |= LD_SDBOTSCALEY;
if (si->repeatcnt != spawnsi->repeatcnt)
diff |= LD_SDREPEATCNT;
return diff;
}
static void ArchiveSide(const side_t *si, UINT32 diff)
{
WRITEUINT32(save_p, diff);
if (diff & LD_SDTEXOFFX)
WRITEFIXED(save_p, si->textureoffset);
if (diff & LD_SDTEXOFFY)
WRITEFIXED(save_p, si->rowoffset);
if (diff & LD_SDTOPTEX)
WRITEINT32(save_p, si->toptexture);
if (diff & LD_SDBOTTEX)
WRITEINT32(save_p, si->bottomtexture);
if (diff & LD_SDMIDTEX)
WRITEINT32(save_p, si->midtexture);
if (diff & LD_SDTOPOFFX)
WRITEFIXED(save_p, si->offsetx_top);
if (diff & LD_SDMIDOFFX)
WRITEFIXED(save_p, si->offsetx_mid);
if (diff & LD_SDBOTOFFX)
WRITEFIXED(save_p, si->offsetx_bottom);
if (diff & LD_SDTOPOFFY)
WRITEFIXED(save_p, si->offsety_top);
if (diff & LD_SDMIDOFFY)
WRITEFIXED(save_p, si->offsety_mid);
if (diff & LD_SDBOTOFFY)
WRITEFIXED(save_p, si->offsety_bottom);
if (diff & LD_SDTOPSCALEX)
WRITEFIXED(save_p, si->scalex_top);
if (diff & LD_SDMIDSCALEX)
WRITEFIXED(save_p, si->scalex_mid);
if (diff & LD_SDBOTSCALEX)
WRITEFIXED(save_p, si->scalex_bottom);
if (diff & LD_SDTOPSCALEY)
WRITEFIXED(save_p, si->scaley_top);
if (diff & LD_SDMIDSCALEY)
WRITEFIXED(save_p, si->scaley_mid);
if (diff & LD_SDBOTSCALEY)
WRITEFIXED(save_p, si->scaley_bottom);
if (diff & LD_SDREPEATCNT)
WRITEINT16(save_p, si->repeatcnt);
}
static void ArchiveLines(void)
{
size_t i;
const line_t *li = lines;
const line_t *spawnli = spawnlines;
const side_t *si;
const side_t *spawnsi;
UINT8 diff, diff2; // no diff3
UINT8 diff;
UINT32 diff2;
UINT32 diff3;
for (i = 0; i < numlines; i++, spawnli++, li++)
{
diff = diff2 = 0;
diff = diff2 = diff3 = 0;
if (li->special != spawnli->special)
diff |= LD_SPECIAL;
@ -1292,84 +1396,44 @@ static void ArchiveLines(void)
diff |= LD_CLLCOUNT;
if (!P_AreArgsEqual(li, spawnli))
diff2 |= LD_ARGS;
diff |= LD_ARGS;
if (!P_AreStringArgsEqual(li, spawnli))
diff2 |= LD_STRINGARGS;
diff |= LD_STRINGARGS;
if (li->executordelay != spawnli->executordelay)
diff2 |= LD_EXECUTORDELAY;
diff |= LD_EXECUTORDELAY;
if (li->sidenum[0] != NO_SIDEDEF)
{
si = &sides[li->sidenum[0]];
spawnsi = &spawnsides[li->sidenum[0]];
if (si->textureoffset != spawnsi->textureoffset)
diff |= LD_S1TEXOFF;
//SoM: 4/1/2000: Some textures are colormaps. Don't worry about invalid textures.
if (si->toptexture != spawnsi->toptexture)
diff |= LD_S1TOPTEX;
if (si->bottomtexture != spawnsi->bottomtexture)
diff |= LD_S1BOTTEX;
if (si->midtexture != spawnsi->midtexture)
diff |= LD_S1MIDTEX;
diff2 = GetSideDiff(&sides[li->sidenum[0]], &spawnsides[li->sidenum[0]]);
if (diff2)
diff |= LD_SIDE1;
}
if (li->sidenum[1] != NO_SIDEDEF)
{
si = &sides[li->sidenum[1]];
spawnsi = &spawnsides[li->sidenum[1]];
if (si->textureoffset != spawnsi->textureoffset)
diff2 |= LD_S2TEXOFF;
if (si->toptexture != spawnsi->toptexture)
diff2 |= LD_S2TOPTEX;
if (si->bottomtexture != spawnsi->bottomtexture)
diff2 |= LD_S2BOTTEX;
if (si->midtexture != spawnsi->midtexture)
diff2 |= LD_S2MIDTEX;
diff3 = GetSideDiff(&sides[li->sidenum[1]], &spawnsides[li->sidenum[1]]);
if (diff3)
diff |= LD_SIDE2;
}
if (diff2)
diff |= LD_DIFF2;
if (diff)
{
WRITEUINT32(save_p, i);
WRITEUINT8(save_p, diff);
if (diff & LD_DIFF2)
WRITEUINT8(save_p, diff2);
if (diff & LD_FLAG)
WRITEINT16(save_p, li->flags);
if (diff & LD_SPECIAL)
WRITEINT16(save_p, li->special);
if (diff & LD_CLLCOUNT)
WRITEINT16(save_p, li->callcount);
si = &sides[li->sidenum[0]];
if (diff & LD_S1TEXOFF)
WRITEFIXED(save_p, si->textureoffset);
if (diff & LD_S1TOPTEX)
WRITEINT32(save_p, si->toptexture);
if (diff & LD_S1BOTTEX)
WRITEINT32(save_p, si->bottomtexture);
if (diff & LD_S1MIDTEX)
WRITEINT32(save_p, si->midtexture);
si = &sides[li->sidenum[1]];
if (diff2 & LD_S2TEXOFF)
WRITEFIXED(save_p, si->textureoffset);
if (diff2 & LD_S2TOPTEX)
WRITEINT32(save_p, si->toptexture);
if (diff2 & LD_S2BOTTEX)
WRITEINT32(save_p, si->bottomtexture);
if (diff2 & LD_S2MIDTEX)
WRITEINT32(save_p, si->midtexture);
if (diff2 & LD_ARGS)
if (diff & LD_ARGS)
{
UINT8 j;
for (j = 0; j < NUMLINEARGS; j++)
WRITEINT32(save_p, li->args[j]);
}
if (diff2 & LD_STRINGARGS)
if (diff & LD_STRINGARGS)
{
UINT8 j;
for (j = 0; j < NUMLINESTRINGARGS; j++)
@ -1388,19 +1452,64 @@ static void ArchiveLines(void)
WRITECHAR(save_p, li->stringargs[j][k]);
}
}
if (diff2 & LD_EXECUTORDELAY)
if (diff & LD_EXECUTORDELAY)
WRITEINT32(save_p, li->executordelay);
if (diff & LD_SIDE1)
ArchiveSide(&sides[li->sidenum[0]], diff2);
if (diff & LD_SIDE2)
ArchiveSide(&sides[li->sidenum[1]], diff3);
}
}
WRITEUINT32(save_p, 0xffffffff);
}
static void UnArchiveSide(side_t *si)
{
UINT32 diff = READUINT32(save_p);
if (diff & LD_SDTEXOFFX)
si->textureoffset = READFIXED(save_p);
if (diff & LD_SDTEXOFFY)
si->rowoffset = READFIXED(save_p);
if (diff & LD_SDTOPTEX)
si->toptexture = READINT32(save_p);
if (diff & LD_SDBOTTEX)
si->bottomtexture = READINT32(save_p);
if (diff & LD_SDMIDTEX)
si->midtexture = READINT32(save_p);
if (diff & LD_SDTOPOFFX)
si->offsetx_top = READFIXED(save_p);
if (diff & LD_SDMIDOFFX)
si->offsetx_mid = READFIXED(save_p);
if (diff & LD_SDBOTOFFX)
si->offsetx_bottom = READFIXED(save_p);
if (diff & LD_SDTOPOFFY)
si->offsety_top = READFIXED(save_p);
if (diff & LD_SDMIDOFFY)
si->offsety_mid = READFIXED(save_p);
if (diff & LD_SDBOTOFFY)
si->offsety_bottom = READFIXED(save_p);
if (diff & LD_SDTOPSCALEX)
si->scalex_top = READFIXED(save_p);
if (diff & LD_SDMIDSCALEX)
si->scalex_mid = READFIXED(save_p);
if (diff & LD_SDBOTSCALEX)
si->scalex_bottom = READFIXED(save_p);
if (diff & LD_SDTOPSCALEY)
si->scaley_top = READFIXED(save_p);
if (diff & LD_SDMIDSCALEY)
si->scaley_mid = READFIXED(save_p);
if (diff & LD_SDBOTSCALEY)
si->scaley_bottom = READFIXED(save_p);
if (diff & LD_SDREPEATCNT)
si->repeatcnt = READINT16(save_p);
}
static void UnArchiveLines(void)
{
UINT32 i;
line_t *li;
side_t *si;
UINT8 diff, diff2; // no diff3
UINT8 diff;
for (;;)
{
@ -1414,44 +1523,19 @@ static void UnArchiveLines(void)
diff = READUINT8(save_p);
li = &lines[i];
if (diff & LD_DIFF2)
diff2 = READUINT8(save_p);
else
diff2 = 0;
if (diff & LD_FLAG)
li->flags = READINT16(save_p);
if (diff & LD_SPECIAL)
li->special = READINT16(save_p);
if (diff & LD_CLLCOUNT)
li->callcount = READINT16(save_p);
si = &sides[li->sidenum[0]];
if (diff & LD_S1TEXOFF)
si->textureoffset = READFIXED(save_p);
if (diff & LD_S1TOPTEX)
si->toptexture = READINT32(save_p);
if (diff & LD_S1BOTTEX)
si->bottomtexture = READINT32(save_p);
if (diff & LD_S1MIDTEX)
si->midtexture = READINT32(save_p);
si = &sides[li->sidenum[1]];
if (diff2 & LD_S2TEXOFF)
si->textureoffset = READFIXED(save_p);
if (diff2 & LD_S2TOPTEX)
si->toptexture = READINT32(save_p);
if (diff2 & LD_S2BOTTEX)
si->bottomtexture = READINT32(save_p);
if (diff2 & LD_S2MIDTEX)
si->midtexture = READINT32(save_p);
if (diff2 & LD_ARGS)
if (diff & LD_ARGS)
{
UINT8 j;
for (j = 0; j < NUMLINEARGS; j++)
li->args[j] = READINT32(save_p);
}
if (diff2 & LD_STRINGARGS)
if (diff & LD_STRINGARGS)
{
UINT8 j;
for (j = 0; j < NUMLINESTRINGARGS; j++)
@ -1472,9 +1556,12 @@ static void UnArchiveLines(void)
li->stringargs[j][len] = '\0';
}
}
if (diff2 & LD_EXECUTORDELAY)
if (diff & LD_EXECUTORDELAY)
li->executordelay = READINT32(save_p);
if (diff & LD_SIDE1)
UnArchiveSide(&sides[li->sidenum[0]]);
if (diff & LD_SIDE2)
UnArchiveSide(&sides[li->sidenum[1]]);
}
}

53
src/p_setup.c
View file

@ -1352,8 +1352,11 @@ static void P_LoadSidedefs(UINT8 *data)
}
sd->rowoffset = SHORT(msd->rowoffset)<<FRACBITS;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bot = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bot = 0;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bottom = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bottom = 0;
sd->scalex_top = sd->scalex_mid = sd->scalex_bottom = FRACUNIT;
sd->scaley_top = sd->scaley_mid = sd->scaley_bottom = FRACUNIT;
P_SetSidedefSector(i, (UINT16)SHORT(msd->sector));
@ -1888,13 +1891,25 @@ static void ParseTextmapSidedefParameter(UINT32 i, const char *param, const char
else if (fastcmp(param, "offsetx_mid"))
sides[i].offsetx_mid = atol(val) << FRACBITS;
else if (fastcmp(param, "offsetx_bottom"))
sides[i].offsetx_bot = atol(val) << FRACBITS;
sides[i].offsetx_bottom = atol(val) << FRACBITS;
else if (fastcmp(param, "offsety_top"))
sides[i].offsety_top = atol(val) << FRACBITS;
else if (fastcmp(param, "offsety_mid"))
sides[i].offsety_mid = atol(val) << FRACBITS;
else if (fastcmp(param, "offsety_bottom"))
sides[i].offsety_bot = atol(val) << FRACBITS;
sides[i].offsety_bottom = atol(val) << FRACBITS;
else if (fastcmp(param, "scalex_top"))
sides[i].scalex_top = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scalex_mid"))
sides[i].scalex_mid = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scalex_bottom"))
sides[i].scalex_bottom = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scaley_top"))
sides[i].scaley_top = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scaley_mid"))
sides[i].scaley_mid = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scaley_bottom"))
sides[i].scaley_bottom = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "texturetop"))
sides[i].toptexture = R_TextureNumForName(val);
else if (fastcmp(param, "texturebottom"))
@ -2599,10 +2614,22 @@ static void P_WriteTextmap(void)
fprintf(f, "offsetx_mid = %d;\n", wsides[i].offsetx_mid >> FRACBITS);
if (wsides[i].offsety_mid != 0)
fprintf(f, "offsety_mid = %d;\n", wsides[i].offsety_mid >> FRACBITS);
if (wsides[i].offsetx_bot != 0)
fprintf(f, "offsetx_bottom = %d;\n", wsides[i].offsetx_bot >> FRACBITS);
if (wsides[i].offsety_bot != 0)
fprintf(f, "offsety_bottom = %d;\n", wsides[i].offsety_bot >> FRACBITS);
if (wsides[i].offsetx_bottom != 0)
fprintf(f, "offsetx_bottom = %d;\n", wsides[i].offsetx_bottom >> FRACBITS);
if (wsides[i].offsety_bottom != 0)
fprintf(f, "offsety_bottom = %d;\n", wsides[i].offsety_bottom >> FRACBITS);
if (wsides[i].scalex_top != FRACUNIT)
fprintf(f, "scalex_top = %f;\n", FIXED_TO_FLOAT(wsides[i].scalex_top));
if (wsides[i].scaley_top != FRACUNIT)
fprintf(f, "scaley_top = %f;\n", FIXED_TO_FLOAT(wsides[i].scaley_top));
if (wsides[i].scalex_mid != FRACUNIT)
fprintf(f, "scalex_mid = %f;\n", FIXED_TO_FLOAT(wsides[i].scalex_mid));
if (wsides[i].scaley_mid != FRACUNIT)
fprintf(f, "scaley_mid = %f;\n", FIXED_TO_FLOAT(wsides[i].scaley_mid));
if (wsides[i].scalex_bottom != FRACUNIT)
fprintf(f, "scalex_bottom = %f;\n", FIXED_TO_FLOAT(wsides[i].scalex_bottom));
if (wsides[i].scaley_bottom != FRACUNIT)
fprintf(f, "scaley_bottom = %f;\n", FIXED_TO_FLOAT(wsides[i].scaley_bottom));
if (wsides[i].toptexture > 0 && wsides[i].toptexture < numtextures)
fprintf(f, "texturetop = \"%.*s\";\n", 8, textures[wsides[i].toptexture]->name);
if (wsides[i].bottomtexture > 0 && wsides[i].bottomtexture < numtextures)
@ -2979,8 +3006,10 @@ static void P_LoadTextmap(void)
// Defaults.
sd->textureoffset = 0;
sd->rowoffset = 0;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bot = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bot = 0;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bottom = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bottom = 0;
sd->scalex_top = sd->scalex_mid = sd->scalex_bottom = FRACUNIT;
sd->scaley_top = sd->scaley_mid = sd->scaley_bottom = FRACUNIT;
sd->toptexture = R_TextureNumForName("-");
sd->midtexture = R_TextureNumForName("-");
sd->bottomtexture = R_TextureNumForName("-");
@ -3306,7 +3335,7 @@ static void P_LoadSegs(UINT8 *data)
seg->length = P_SegLength(seg);
#ifdef HWRENDER
seg->flength = (rendermode == render_opengl) ? P_SegLengthFloat(seg) : 0;
seg->flength = P_SegLengthFloat(seg);
#endif
seg->glseg = false;
@ -3548,7 +3577,7 @@ static boolean P_LoadExtendedSubsectorsAndSegs(UINT8 **data, nodetype_t nodetype
}
seg->length = P_SegLength(seg);
#ifdef HWRENDER
seg->flength = (rendermode == render_opengl) ? P_SegLengthFloat(seg) : 0;
seg->flength = P_SegLengthFloat(seg);
#endif
}

10
src/r_defs.h
View file

@ -564,8 +564,11 @@ typedef struct
fixed_t rowoffset;
// per-texture offsets for UDMF
fixed_t offsetx_top, offsetx_mid, offsetx_bot;
fixed_t offsety_top, offsety_mid, offsety_bot;
fixed_t offsetx_top, offsetx_mid, offsetx_bottom;
fixed_t offsety_top, offsety_mid, offsety_bottom;
fixed_t scalex_top, scalex_mid, scalex_bottom;
fixed_t scaley_top, scaley_mid, scaley_bottom;
// Texture indices.
// We do not maintain names here.
@ -759,10 +762,13 @@ typedef struct drawseg_s
fixed_t bsilheight; // do not clip sprites above this
fixed_t tsilheight; // do not clip sprites below this
fixed_t offsetx;
// Pointers to lists for sprite clipping, all three adjusted so [x1] is first value.
INT16 *sprtopclip;
INT16 *sprbottomclip;
fixed_t *maskedtexturecol;
fixed_t *invscale;
struct visplane_s *ffloorplanes[MAXFFLOORS];
INT32 numffloorplanes;

402
src/r_segs.c
View file

@ -48,15 +48,18 @@ fixed_t rw_distance;
//
static INT32 rw_x, rw_stopx;
static angle_t rw_centerangle;
static fixed_t rw_offset;
static fixed_t rw_offset_top, rw_offset_mid, rw_offset_bot;
static fixed_t rw_offset2; // for splats
static fixed_t rw_offset, rw_offsetx;
static fixed_t rw_offset_top, rw_offset_mid, rw_offset_bottom;
static fixed_t rw_scale, rw_scalestep;
static fixed_t rw_midtexturemid, rw_toptexturemid, rw_bottomtexturemid;
static INT32 worldtop, worldbottom, worldhigh, worldlow;
static INT32 worldtopslope, worldbottomslope, worldhighslope, worldlowslope; // worldtop/bottom at end of slope
static fixed_t rw_toptextureslide, rw_midtextureslide, rw_bottomtextureslide; // Defines how to adjust Y offsets along the wall for slopes
static fixed_t rw_midtextureback, rw_midtexturebackslide; // Values for masked midtexture height calculation
static fixed_t rw_midtexturescalex, rw_midtexturescaley;
static fixed_t rw_toptexturescalex, rw_toptexturescaley;
static fixed_t rw_bottomtexturescalex, rw_bottomtexturescaley;
static fixed_t rw_invmidtexturescalex, rw_invtoptexturescalex, rw_invbottomtexturescalex;
// Lactozilla: 3D floor clipping
static boolean rw_floormarked = false;
@ -71,8 +74,10 @@ static fixed_t topfrac, topstep;
static fixed_t bottomfrac, bottomstep;
static lighttable_t **walllights;
static fixed_t *maskedtexturecol;
static fixed_t *maskedtexturecol = NULL;
static fixed_t *maskedtextureheight = NULL;
static fixed_t *thicksidecol = NULL;
static fixed_t *invscale = NULL;
//SoM: 3/23/2000: Use boom opening limit removal
static size_t numopenings;
@ -162,7 +167,8 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
frontsector = curline->frontsector;
backsector = curline->backsector;
texnum = R_GetTextureNum(curline->sidedef->midtexture);
sidedef = curline->sidedef;
texnum = R_GetTextureNum(sidedef->midtexture);
windowbottom = windowtop = sprbotscreen = INT32_MAX;
ldef = curline->linedef;
@ -200,9 +206,13 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
colfunc = colfuncs[COLDRAWFUNC_FUZZY];
}
fixed_t wall_scaley = sidedef->scaley_mid;
fixed_t scalestep = FixedDiv(ds->scalestep, wall_scaley);
fixed_t scale1 = FixedDiv(ds->scale1, wall_scaley);
range = max(ds->x2-ds->x1, 1);
rw_scalestep = ds->scalestep;
spryscale = ds->scale1 + (x1 - ds->x1)*rw_scalestep;
rw_scalestep = scalestep;
spryscale = scale1 + (x1 - ds->x1)*rw_scalestep;
// Texture must be cached before setting colfunc_2s,
// otherwise texture[texnum]->holes may be false when it shouldn't be
@ -313,8 +323,8 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
else
back = backsector;
if (ds->curline->sidedef->repeatcnt)
repeats = 1 + ds->curline->sidedef->repeatcnt;
if (sidedef->repeatcnt)
repeats = 1 + sidedef->repeatcnt;
else if (ldef->flags & ML_WRAPMIDTEX)
{
fixed_t high, low;
@ -340,15 +350,14 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
{
if (times > 0)
{
rw_scalestep = ds->scalestep;
spryscale = ds->scale1 + (x1 - ds->x1)*rw_scalestep;
if (dc_numlights)
{ // reset all lights to their starting heights
for (i = 0; i < dc_numlights; i++)
{
rlight = &dc_lightlist[i];
rlight->height = rlight->startheight;
}
rw_scalestep = scalestep;
spryscale = scale1 + (x1 - ds->x1)*rw_scalestep;
// reset all lights to their starting heights
for (i = 0; i < dc_numlights; i++)
{
rlight = &dc_lightlist[i];
rlight->height = rlight->startheight;
}
}
@ -390,8 +399,10 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
sprbotscreen = INT32_MAX;
sprtopscreen = windowtop = (centeryfrac - FixedMul(dc_texturemid, spryscale));
realbot = windowbottom = FixedMul(textureheight[texnum], spryscale) + sprtopscreen;
dc_iscale = 0xffffffffu / (unsigned)spryscale;
realbot = FixedMul(textureheight[texnum], spryscale) + sprtopscreen;
dc_iscale = FixedMul(ds->invscale[dc_x], wall_scaley);
windowbottom = realbot;
// draw the texture
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (maskedtexturecol[dc_x] >> FRACBITS)) - 3);
@ -466,7 +477,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
dc_colormap = frontsector->extra_colormap->colormap + (dc_colormap - colormaps);
sprtopscreen = centeryfrac - FixedMul(dc_texturemid, spryscale);
dc_iscale = 0xffffffffu / (unsigned)spryscale;
dc_iscale = FixedMul(ds->invscale[dc_x], wall_scaley);
// draw the texture
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (maskedtexturecol[dc_x] >> FRACBITS)) - 3);
@ -525,7 +536,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
INT32 i, p;
fixed_t bottombounds = viewheight << FRACBITS;
fixed_t topbounds = (con_clipviewtop - 1) << FRACBITS;
fixed_t offsetvalue = 0;
fixed_t offsetvalue;
lightlist_t *light;
r_lightlist_t *rlight;
INT32 range;
@ -534,11 +545,13 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
// NOTE: INT64 instead of fixed_t because overflow concerns
INT64 top_frac, top_step, bottom_frac, bottom_step;
// skew FOF walls with slopes?
boolean slopeskew = false;
fixed_t ffloortextureslide = 0;
INT32 oldx = -1;
fixed_t left_top, left_bottom; // needed here for slope skewing
pslope_t *skewslope = NULL;
boolean do_texture_skew;
UINT32 lineflags;
fixed_t wall_scalex, wall_scaley;
void (*colfunc_2s) (column_t *);
@ -550,7 +563,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
curline = ds->curline;
backsector = pfloor->target;
frontsector = curline->frontsector == pfloor->target ? curline->backsector : curline->frontsector;
texnum = R_GetTextureNum(sides[pfloor->master->sidenum[0]].midtexture);
sidedef = &sides[pfloor->master->sidenum[0]];
colfunc = colfuncs[BASEDRAWFUNC];
@ -558,8 +571,13 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
{
size_t linenum = curline->linedef-backsector->lines[0];
newline = pfloor->master->frontsector->lines[0] + linenum;
texnum = R_GetTextureNum(sides[newline->sidenum[0]].midtexture);
sidedef = &sides[newline->sidenum[0]];
lineflags = newline->flags;
}
else
lineflags = pfloor->master->flags;
texnum = R_GetTextureNum(sidedef->midtexture);
if (pfloor->fofflags & FOF_TRANSLUCENT)
{
@ -711,7 +729,13 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
walllights = scalelight[lightnum];
}
maskedtexturecol = ds->thicksidecol;
wall_scalex = FixedDiv(FRACUNIT, sidedef->scalex_mid);
wall_scaley = sidedef->scaley_mid;
thicksidecol = ds->thicksidecol;
for (INT32 x = x1; x <= x2; x++)
thicksidecol[x] = FixedDiv(thicksidecol[x], wall_scalex) + ds->offsetx;
mfloorclip = ds->sprbottomclip;
mceilingclip = ds->sprtopclip;
@ -721,51 +745,29 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
left_top = P_GetFFloorTopZAt (pfloor, ds->leftpos.x, ds->leftpos.y) - viewz;
left_bottom = P_GetFFloorBottomZAt(pfloor, ds->leftpos.x, ds->leftpos.y) - viewz;
do_texture_skew = lineflags & ML_SKEWTD;
skewslope = *pfloor->t_slope; // skew using top slope by default
if (newline)
{
if (newline->flags & ML_SKEWTD)
slopeskew = true;
}
else if (pfloor->master->flags & ML_SKEWTD)
slopeskew = true;
if (slopeskew)
dc_texturemid = left_top;
if (do_texture_skew)
dc_texturemid = FixedMul(left_top, wall_scaley);
else
dc_texturemid = *pfloor->topheight - viewz;
dc_texturemid = FixedMul(*pfloor->topheight - viewz, wall_scaley);
if (newline)
offsetvalue = sidedef->rowoffset + sidedef->offsety_mid;
if (lineflags & ML_DONTPEGBOTTOM)
{
offsetvalue = sides[newline->sidenum[0]].rowoffset + sides[newline->sidenum[0]].offsety_mid;
if (newline->flags & ML_DONTPEGBOTTOM)
{
skewslope = *pfloor->b_slope; // skew using bottom slope
if (slopeskew)
dc_texturemid = left_bottom;
else
offsetvalue -= *pfloor->topheight - *pfloor->bottomheight;
}
}
else
{
offsetvalue = sides[pfloor->master->sidenum[0]].rowoffset + sides[pfloor->master->sidenum[0]].offsety_mid;
if (curline->linedef->flags & ML_DONTPEGBOTTOM)
{
skewslope = *pfloor->b_slope; // skew using bottom slope
if (slopeskew)
dc_texturemid = left_bottom;
else
offsetvalue -= *pfloor->topheight - *pfloor->bottomheight;
}
skewslope = *pfloor->b_slope; // skew using bottom slope
if (do_texture_skew)
dc_texturemid = FixedMul(left_bottom, wall_scaley);
else
offsetvalue -= FixedMul(*pfloor->topheight - *pfloor->bottomheight, wall_scaley);
}
if (slopeskew)
if (do_texture_skew && skewslope)
{
angle_t lineangle = R_PointToAngle2(curline->v1->x, curline->v1->y, curline->v2->x, curline->v2->y);
if (skewslope)
ffloortextureslide = FixedMul(skewslope->zdelta, FINECOSINE((lineangle-skewslope->xydirection)>>ANGLETOFINESHIFT));
ffloortextureslide = FixedMul(skewslope->zdelta, FINECOSINE((lineangle-skewslope->xydirection)>>ANGLETOFINESHIFT));
}
dc_texturemid += offsetvalue;
@ -819,7 +821,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
if (ffloortextureslide)
{
if (oldx != -1)
dc_texturemid += FixedMul(ffloortextureslide, maskedtexturecol[oldx]-maskedtexturecol[dc_x]);
dc_texturemid += FixedMul(ffloortextureslide, thicksidecol[oldx]-thicksidecol[dc_x]);
oldx = dc_x;
}
@ -852,10 +854,10 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
continue;
}
dc_iscale = 0xffffffffu / (unsigned)spryscale;
dc_iscale = FixedMul(0xffffffffu / (unsigned)spryscale, wall_scaley);
// Get data for the column
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (maskedtexturecol[dc_x] >> FRACBITS)) - 3);
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (thicksidecol[dc_x] >> FRACBITS)) - 3);
// SoM: New code does not rely on R_DrawColumnShadowed_8 which
// will (hopefully) put less strain on the stack.
@ -1044,13 +1046,18 @@ UINT32 nombre = 100000;
static void R_RenderSegLoop (void)
{
angle_t angle;
fixed_t textureoffset;
size_t pindex;
INT32 yl;
INT32 yh;
INT32 mid;
fixed_t texturecolumn = 0;
fixed_t toptexturecolumn = 0;
fixed_t bottomtexturecolumn = 0;
fixed_t oldtexturecolumn = -1;
fixed_t oldtexturecolumn_top = -1;
fixed_t oldtexturecolumn_bottom = -1;
INT32 top;
INT32 bottom;
INT32 i;
@ -1217,17 +1224,8 @@ static void R_RenderSegLoop (void)
//SoM: Calculate offsets for Thick fake floors.
// calculate texture offset
angle = (rw_centerangle + xtoviewangle[rw_x])>>ANGLETOFINESHIFT;
texturecolumn = rw_offset-FixedMul(FINETANGENT(angle),rw_distance);
if (oldtexturecolumn != -1) {
rw_bottomtexturemid += FixedMul(rw_bottomtextureslide, oldtexturecolumn-texturecolumn);
rw_midtexturemid += FixedMul(rw_midtextureslide, oldtexturecolumn-texturecolumn);
rw_toptexturemid += FixedMul(rw_toptextureslide, oldtexturecolumn-texturecolumn);
rw_midtextureback += FixedMul(rw_midtexturebackslide, oldtexturecolumn-texturecolumn);
}
oldtexturecolumn = texturecolumn;
INT32 itexturecolumn = texturecolumn >> FRACBITS;
textureoffset = rw_offset - FixedMul(FINETANGENT(angle), rw_distance);
texturecolumn = FixedDiv(textureoffset, rw_invmidtexturescalex);
// texturecolumn and lighting are independent of wall tiers
if (segtextured)
@ -1240,7 +1238,6 @@ static void R_RenderSegLoop (void)
dc_colormap = walllights[pindex];
dc_x = rw_x;
dc_iscale = 0xffffffffu / (unsigned)rw_scale;
if (frontsector->extra_colormap)
dc_colormap = frontsector->extra_colormap->colormap + (dc_colormap - colormaps);
@ -1290,10 +1287,13 @@ static void R_RenderSegLoop (void)
// single sided line
if (yl <= yh && yh >= 0 && yl < viewheight)
{
fixed_t offset = texturecolumn + rw_offsetx;
dc_yl = yl;
dc_yh = yh;
dc_texturemid = rw_midtexturemid;
dc_source = R_GetColumn(midtexture, itexturecolumn + (rw_offset_mid>>FRACBITS));
dc_iscale = FixedMul(0xffffffffu / (unsigned)rw_scale, rw_midtexturescaley);
dc_source = R_GetColumn(midtexture, offset >> FRACBITS);
dc_texheight = textureheight[midtexture]>>FRACBITS;
//profile stuff ---------------------------------------------------------
@ -1342,6 +1342,8 @@ static void R_RenderSegLoop (void)
if (mid >= floorclip[rw_x])
mid = floorclip[rw_x]-1;
toptexturecolumn = FixedDiv(textureoffset, rw_invtoptexturescalex);
if (mid >= yl) // back ceiling lower than front ceiling ?
{
if (yl >= viewheight) // entirely off bottom of screen
@ -1351,10 +1353,16 @@ static void R_RenderSegLoop (void)
}
else if (mid >= 0) // safe to draw top texture
{
fixed_t offset = rw_offset_top;
if (rw_toptexturescalex < 0)
offset = -offset;
offset = toptexturecolumn + offset;
dc_yl = yl;
dc_yh = mid;
dc_texturemid = rw_toptexturemid;
dc_source = R_GetColumn(toptexture, itexturecolumn + (rw_offset_top>>FRACBITS));
dc_iscale = FixedMul(0xffffffffu / (unsigned)rw_scale, rw_toptexturescaley);
dc_source = R_GetColumn(toptexture, offset >> FRACBITS);
dc_texheight = textureheight[toptexture]>>FRACBITS;
colfunc();
ceilingclip[rw_x] = (INT16)mid;
@ -1364,6 +1372,10 @@ static void R_RenderSegLoop (void)
}
else if (!rw_ceilingmarked)
ceilingclip[rw_x] = topclip;
if (oldtexturecolumn_top != -1)
rw_toptexturemid += FixedMul(rw_toptextureslide, oldtexturecolumn_top-toptexturecolumn);
oldtexturecolumn_top = toptexturecolumn;
}
else if (markceiling && (!rw_ceilingmarked)) // no top wall
ceilingclip[rw_x] = topclip;
@ -1378,6 +1390,8 @@ static void R_RenderSegLoop (void)
if (mid <= ceilingclip[rw_x])
mid = ceilingclip[rw_x]+1;
bottomtexturecolumn = FixedDiv(textureoffset, rw_invbottomtexturescalex);
if (mid <= yh) // back floor higher than front floor ?
{
if (yh < 0) // entirely off top of screen
@ -1387,10 +1401,16 @@ static void R_RenderSegLoop (void)
}
else if (mid < viewheight) // safe to draw bottom texture
{
fixed_t offset = rw_offset_bottom;
if (rw_bottomtexturescalex < 0)
offset = -offset;
offset = bottomtexturecolumn + offset;
dc_yl = mid;
dc_yh = yh;
dc_texturemid = rw_bottomtexturemid;
dc_source = R_GetColumn(bottomtexture, itexturecolumn + (rw_offset_bot>>FRACBITS));
dc_iscale = FixedMul(0xffffffffu / (unsigned)rw_scale, rw_bottomtexturescaley);
dc_source = R_GetColumn(bottomtexture, offset >> FRACBITS);
dc_texheight = textureheight[bottomtexture]>>FRACBITS;
colfunc();
floorclip[rw_x] = (INT16)mid;
@ -1400,24 +1420,43 @@ static void R_RenderSegLoop (void)
}
else if (!rw_floormarked)
floorclip[rw_x] = bottomclip;
if (oldtexturecolumn_bottom != -1)
rw_bottomtexturemid += FixedMul(rw_bottomtextureslide, oldtexturecolumn_bottom-bottomtexturecolumn);
oldtexturecolumn_bottom = bottomtexturecolumn;
}
else if (markfloor && (!rw_floormarked)) // no bottom wall
floorclip[rw_x] = bottomclip;
}
if (maskedtexture || numthicksides)
{
// save texturecol
// for backdrawing of masked mid texture
maskedtexturecol[rw_x] = texturecolumn + rw_offset_mid;
if (maskedtexturecol)
maskedtexturecol[rw_x] = texturecolumn + rw_offsetx;
if (maskedtextureheight != NULL) {
maskedtextureheight[rw_x] = (curline->linedef->flags & ML_MIDPEG) ?
max(rw_midtexturemid, rw_midtextureback) :
min(rw_midtexturemid, rw_midtextureback);
}
if (thicksidecol)
thicksidecol[rw_x] = textureoffset;
if (maskedtextureheight)
{
if (curline->linedef->flags & ML_MIDPEG)
maskedtextureheight[rw_x] = max(rw_midtexturemid, rw_midtextureback);
else
maskedtextureheight[rw_x] = min(rw_midtexturemid, rw_midtextureback);
}
if (midtexture || maskedtextureheight)
{
if (oldtexturecolumn != -1)
{
rw_midtexturemid += FixedMul(rw_midtextureslide, oldtexturecolumn-texturecolumn);
rw_midtextureback += FixedMul(rw_midtexturebackslide, oldtexturecolumn-texturecolumn);
}
oldtexturecolumn = texturecolumn;
}
if (invscale)
invscale[rw_x] = 0xffffffffu / (unsigned)rw_scale;
if (dc_numlights)
{
for (i = 0; i < dc_numlights; i++)
@ -1506,10 +1545,9 @@ static void R_AllocClippingTables(size_t range)
static void R_AllocTextureColumnTables(size_t range)
{
size_t pos = curtexturecolumntable - texturecolumntable;
size_t need = range * 3;
// For both tables, we reserve exactly an amount of memory that's equivalent to
// how many columns the seg will take on the entire screen (think about it)
if (pos + range < texturecolumntablesize)
if (pos + need < texturecolumntablesize)
return;
fixed_t *oldtable = texturecolumntable;
@ -1518,7 +1556,7 @@ static void R_AllocTextureColumnTables(size_t range)
if (texturecolumntablesize == 0)
texturecolumntablesize = 16384;
texturecolumntablesize += range;
texturecolumntablesize += need;
texturecolumntable = Z_Realloc(texturecolumntable, texturecolumntablesize * sizeof (*texturecolumntable), PU_STATIC, NULL);
curtexturecolumntable = texturecolumntable + pos;
@ -1532,6 +1570,8 @@ static void R_AllocTextureColumnTables(size_t range)
ds->maskedtexturecol = (ds->maskedtexturecol - oldtable) + texturecolumntable;
if (ds->thicksidecol + ds->x1 >= oldtable && ds->thicksidecol + ds->x1 <= oldlast)
ds->thicksidecol = (ds->thicksidecol - oldtable) + texturecolumntable;
if (ds->invscale + ds->x1 >= oldtable && ds->invscale + ds->x1 <= oldlast)
ds->invscale = (ds->invscale - oldtable) + texturecolumntable;
}
}
@ -1555,7 +1595,11 @@ void R_StoreWallRange(INT32 start, INT32 stop)
fixed_t ceilingfrontslide, floorfrontslide, ceilingbackslide, floorbackslide;
static size_t maxdrawsegs = 0;
maskedtexturecol = NULL;
maskedtextureheight = NULL;
thicksidecol = NULL;
invscale = NULL;
//initialize segleft and segright
memset(&segleft, 0x00, sizeof(segleft));
memset(&segright, 0x00, sizeof(segright));
@ -1712,6 +1756,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
ds_p->maskedtexturecol = NULL;
ds_p->numthicksides = numthicksides = 0;
ds_p->thicksidecol = NULL;
ds_p->invscale = NULL;
ds_p->tsilheight = 0;
numbackffloors = 0;
@ -1751,32 +1796,67 @@ void R_StoreWallRange(INT32 start, INT32 stop)
ceilingbackslide = FixedMul(backsector->c_slope->zdelta, FINECOSINE((lineangle-backsector->c_slope->xydirection)>>ANGLETOFINESHIFT));
}
rw_midtexturescalex = sidedef->scalex_mid;
rw_midtexturescaley = sidedef->scaley_mid;
rw_invmidtexturescalex = FixedDiv(FRACUNIT, rw_midtexturescalex);
if (!backsector)
{
fixed_t texheight;
// single sided line
midtexture = R_GetTextureNum(sidedef->midtexture);
texheight = textureheight[midtexture];
// a single sided line is terminal, so it must mark ends
markfloor = markceiling = true;
if (linedef->flags & ML_NOSKEW) {
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_midtexturemid = frontsector->floorheight + texheight - viewz;
else
rw_midtexturemid = frontsector->ceilingheight - viewz;
}
else if (linedef->flags & ML_DONTPEGBOTTOM)
fixed_t rowoffset = sidedef->rowoffset + sidedef->offsety_mid;
fixed_t texheight = textureheight[midtexture];
if (rw_midtexturescaley > 0)
{
rw_midtexturemid = worldbottom + texheight;
rw_midtextureslide = floorfrontslide;
if (linedef->flags & ML_NOSKEW)
{
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_midtexturemid = FixedMul(frontsector->floorheight - viewz, rw_midtexturescaley) + texheight;
else
rw_midtexturemid = FixedMul(frontsector->ceilingheight - viewz, rw_midtexturescaley);
}
else if (linedef->flags & ML_DONTPEGBOTTOM)
{
rw_midtexturemid = FixedMul(worldbottom, rw_midtexturescaley) + texheight;
rw_midtextureslide = floorfrontslide;
}
else
{
// top of texture at top
rw_midtexturemid = FixedMul(worldtop, rw_midtexturescaley);
rw_midtextureslide = ceilingfrontslide;
}
}
else
{
// top of texture at top
rw_midtexturemid = worldtop;
rw_midtextureslide = ceilingfrontslide;
// Upside down
rowoffset = -rowoffset;
if (linedef->flags & ML_NOSKEW)
{
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_midtexturemid = FixedMul(frontsector->floorheight - viewz, rw_midtexturescaley);
else
rw_midtexturemid = FixedMul(frontsector->ceilingheight - viewz, rw_midtexturescaley) + texheight;
}
else if (linedef->flags & ML_DONTPEGBOTTOM)
{
rw_midtexturemid = FixedMul(worldbottom, rw_midtexturescaley);
rw_midtextureslide = floorfrontslide;
}
else
{
// top of texture at top
rw_midtexturemid = FixedMul(worldtop, rw_midtexturescaley) + texheight;
rw_midtextureslide = ceilingfrontslide;
}
}
rw_midtexturemid += sidedef->rowoffset + sidedef->offsety_mid;
rw_midtexturemid += rowoffset;
ds_p->silhouette = SIL_BOTH;
ds_p->sprtopclip = screenheightarray;
@ -1962,16 +2042,28 @@ void R_StoreWallRange(INT32 start, INT32 stop)
}
}
fixed_t toprowoffset = sidedef->rowoffset + sidedef->offsety_top;
fixed_t botrowoffset = sidedef->rowoffset + sidedef->offsety_bottom;
// check TOP TEXTURE
if (!bothceilingssky // never draw the top texture if on
&& (worldhigh < worldtop || worldhighslope < worldtopslope))
{
fixed_t texheight;
// top texture
toptexture = R_GetTextureNum(sidedef->toptexture);
texheight = textureheight[toptexture];
if (!(linedef->flags & ML_SKEWTD)) { // Ignore slopes for lower/upper textures unless flag is checked
rw_toptexturescalex = sidedef->scalex_top;
rw_toptexturescaley = sidedef->scaley_top;
rw_invtoptexturescalex = FixedDiv(FRACUNIT, rw_toptexturescalex);
if (rw_toptexturescaley < 0)
toprowoffset = -toprowoffset;
fixed_t texheight = textureheight[toptexture];
// Ignore slopes for lower/upper textures unless flag is checked
if (!(linedef->flags & ML_SKEWTD))
{
if (linedef->flags & ML_DONTPEGTOP)
rw_toptexturemid = frontsector->ceilingheight - viewz;
else
@ -1988,7 +2080,10 @@ void R_StoreWallRange(INT32 start, INT32 stop)
rw_toptexturemid = worldhigh + texheight;
rw_toptextureslide = ceilingbackslide;
}
rw_toptexturemid = FixedMul(rw_toptexturemid, rw_toptexturescaley);
}
// check BOTTOM TEXTURE
if (!bothfloorssky // never draw the bottom texture if on
&& (worldlow > worldbottom || worldlowslope > worldbottomslope)) // Only if VISIBLE!!!
@ -1996,7 +2091,17 @@ void R_StoreWallRange(INT32 start, INT32 stop)
// bottom texture
bottomtexture = R_GetTextureNum(sidedef->bottomtexture);
if (!(linedef->flags & ML_SKEWTD)) { // Ignore slopes for lower/upper textures unless flag is checked
rw_bottomtexturescalex = sidedef->scalex_bottom;
rw_bottomtexturescaley = sidedef->scaley_bottom;
rw_invbottomtexturescalex = FixedDiv(FRACUNIT, rw_bottomtexturescalex);
if (rw_bottomtexturescaley < 0)
botrowoffset = -botrowoffset;
// Ignore slopes for lower/upper textures unless flag is checked
if (!(linedef->flags & ML_SKEWTD))
{
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_bottomtexturemid = frontsector->floorheight - viewz;
else
@ -2009,18 +2114,22 @@ void R_StoreWallRange(INT32 start, INT32 stop)
rw_bottomtexturemid = worldbottom;
rw_bottomtextureslide = floorfrontslide;
}
else { // top of texture at top
else
{
// top of texture at top
rw_bottomtexturemid = worldlow;
rw_bottomtextureslide = floorbackslide;
}
rw_bottomtexturemid = FixedMul(rw_bottomtexturemid, rw_bottomtexturescaley);
}
rw_toptexturemid += sidedef->rowoffset + sidedef->offsety_top;
rw_bottomtexturemid += sidedef->rowoffset + sidedef->offsety_bot;
R_AllocTextureColumnTables(rw_stopx - start);
rw_toptexturemid += toprowoffset;
rw_bottomtexturemid += botrowoffset;
// allocate space for masked texture tables
R_AllocTextureColumnTables(rw_stopx - start);
if (frontsector && backsector && !Tag_Compare(&frontsector->tags, &backsector->tags) && (backsector->ffloors || frontsector->ffloors))
{
ffloor_t *rover;
@ -2031,10 +2140,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
// Used for height comparisons and etc across FOFs and slopes
fixed_t high1, highslope1, low1, lowslope1, high2, highslope2, low2, lowslope2;
//markceiling = markfloor = true;
maskedtexture = true;
ds_p->thicksidecol = maskedtexturecol = curtexturecolumntable - rw_x;
ds_p->thicksidecol = thicksidecol = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
lowcut = max(worldbottom, worldlow) + viewz;
@ -2213,21 +2321,20 @@ void R_StoreWallRange(INT32 start, INT32 stop)
ds_p->numthicksides = numthicksides = i;
}
// masked midtexture
if (sidedef->midtexture > 0 && sidedef->midtexture < numtextures)
{
// masked midtexture
if (!ds_p->thicksidecol)
{
ds_p->maskedtexturecol = maskedtexturecol = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
}
else
ds_p->maskedtexturecol = ds_p->thicksidecol;
ds_p->maskedtexturecol = maskedtexturecol = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
maskedtextureheight = ds_p->maskedtextureheight; // note to red, this == &(ds_p->maskedtextureheight[0])
maskedtexture = true;
if (curline->polyseg)
{ // use REAL front and back floors please, so midtexture rendering isn't mucked up
{
// use REAL front and back floors please, so midtexture rendering isn't mucked up
rw_midtextureslide = rw_midtexturebackslide = 0;
if (linedef->flags & ML_MIDPEG)
rw_midtexturemid = rw_midtextureback = max(curline->frontsector->floorheight, curline->backsector->floorheight) - viewz;
@ -2238,7 +2345,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
{
// Set midtexture starting height
if (linedef->flags & ML_NOSKEW)
{ // Ignore slopes when texturing
{
// Ignore slopes when texturing
rw_midtextureslide = rw_midtexturebackslide = 0;
if (linedef->flags & ML_MIDPEG)
rw_midtexturemid = rw_midtextureback = max(frontsector->floorheight, backsector->floorheight) - viewz;
@ -2261,6 +2369,10 @@ void R_StoreWallRange(INT32 start, INT32 stop)
rw_midtexturebackslide = ceilingbackslide;
}
}
rw_midtexturemid = FixedMul(rw_midtexturemid, rw_midtexturescaley);
rw_midtextureback = FixedMul(rw_midtextureback, rw_midtexturescaley);
rw_midtexturemid += sidedef->rowoffset + sidedef->offsety_mid;
rw_midtextureback += sidedef->rowoffset + sidedef->offsety_mid;
@ -2273,6 +2385,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if (segtextured)
{
fixed_t sideoffset = sidedef->textureoffset;
offsetangle = rw_normalangle-rw_angle1;
if (offsetangle > ANGLE_180)
@ -2297,14 +2411,20 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if (rw_normalangle-rw_angle1 < ANGLE_180)
rw_offset = -rw_offset;
/// don't use texture offset for splats
rw_offset2 = rw_offset + curline->offset;
rw_offset += sidedef->textureoffset + curline->offset;
rw_offset_top = sidedef->offsetx_top;
rw_offset_mid = sidedef->offsetx_mid;
rw_offset_bot = sidedef->offsetx_bot;
rw_offset += curline->offset;
rw_centerangle = ANGLE_90 + viewangle - rw_normalangle;
rw_offset_top = sideoffset + sidedef->offsetx_top;
rw_offset_mid = sideoffset + sidedef->offsetx_mid;
rw_offset_bottom = sideoffset + sidedef->offsetx_bottom;
rw_offsetx = rw_offset_mid;
if (rw_midtexturescalex < 0)
rw_offsetx = -rw_offsetx;
if (numthicksides)
ds_p->offsetx = rw_offsetx;
// calculate light table
// use different light tables
// for horizontal / vertical / diagonal
@ -2324,6 +2444,12 @@ void R_StoreWallRange(INT32 start, INT32 stop)
walllights = scalelight[lightnum];
}
if (maskedtexture)
{
ds_p->invscale = invscale = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
}
// if a floor / ceiling plane is on the wrong side
// of the view plane, it is definitely invisible
// and doesn't need to be marked.