diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c
index 2b51e3d059fd0a6d4ceff86b21178bf7c0d48666..4e3ff432b4e2bb67ab51e1ba3e2f87fc63dbdf5a 100644
--- a/src/hardware/hw_main.c
+++ b/src/hardware/hw_main.c
@@ -372,11 +372,9 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
INT32 i;
float height; // constant y for all points on the convex flat polygon
- float flatxref, flatyref, anglef = 0.0f;
+ float anglef = 0.0f;
float fflatwidth = 64.0f, fflatheight = 64.0f;
- UINT16 flatflag = 63;
-
- boolean texflat = false;
+ float xscale = 1.0f, yscale = 1.0f;
float tempxsow, tempytow;
float scrollx = 0.0f, scrolly = 0.0f;
@@ -411,11 +409,7 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
slope = gl_frontsector->c_slope;
}
- // Set fixedheight to the slope's height from our viewpoint, if we have a slope
- if (slope)
- fixedheight = P_GetSlopeZAt(slope, viewx, viewy);
-
- height = FIXED_TO_FLOAT(fixedheight);
+ height = FixedToFloat(fixedheight);
// Allocate plane-vertex buffer if we need to
if (!planeVerts || nrPlaneVerts > numAllocedPlaneVerts)
@@ -431,8 +425,8 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
if (levelflat->type == LEVELFLAT_FLAT)
{
size_t len = W_LumpLength(levelflat->u.flat.lumpnum);
- flatflag = R_GetFlatSize(len) - 1;
- fflatwidth = fflatheight = (float)(flatflag + 1);
+ unsigned flatflag = R_GetFlatSize(len);
+ fflatwidth = fflatheight = (float)flatflag;
}
else
{
@@ -446,29 +440,28 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
fflatwidth = levelflat->width;
fflatheight = levelflat->height;
}
- texflat = true;
}
}
else // set no texture
HWR_SetCurrentTexture(NULL);
- // reference point for flat texture coord for each vertex around the polygon
- flatxref = (float)(((fixed_t)pv->x & (~flatflag)) / fflatwidth);
- flatyref = (float)(((fixed_t)pv->y & (~flatflag)) / fflatheight);
-
// transform
if (FOFsector != NULL)
{
if (!isceiling) // it's a floor
{
- scrollx = FIXED_TO_FLOAT(FOFsector->floorxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(FOFsector->flooryoffset)/fflatheight;
+ xscale = FixedToFloat(FOFsector->floorxscale);
+ yscale = FixedToFloat(FOFsector->flooryscale);
+ scrollx = FixedToFloat(FOFsector->floorxoffset) / fflatwidth;
+ scrolly = FixedToFloat(FOFsector->flooryoffset) / fflatheight;
angle = FOFsector->floorangle;
}
else // it's a ceiling
{
- scrollx = FIXED_TO_FLOAT(FOFsector->ceilingxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(FOFsector->ceilingyoffset)/fflatheight;
+ xscale = FixedToFloat(FOFsector->ceilingxscale);
+ yscale = FixedToFloat(FOFsector->ceilingyscale);
+ scrollx = FixedToFloat(FOFsector->ceilingxoffset) / fflatwidth;
+ scrolly = FixedToFloat(FOFsector->ceilingyoffset) / fflatheight;
angle = FOFsector->ceilingangle;
}
}
@@ -476,41 +469,28 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
{
if (!isceiling) // it's a floor
{
- scrollx = FIXED_TO_FLOAT(gl_frontsector->floorxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(gl_frontsector->flooryoffset)/fflatheight;
+ xscale = FixedToFloat(gl_frontsector->floorxscale);
+ yscale = FixedToFloat(gl_frontsector->flooryscale);
+ scrollx = FixedToFloat(gl_frontsector->floorxoffset) / fflatwidth;
+ scrolly = FixedToFloat(gl_frontsector->flooryoffset) / fflatheight;
angle = gl_frontsector->floorangle;
}
else // it's a ceiling
{
- scrollx = FIXED_TO_FLOAT(gl_frontsector->ceilingxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(gl_frontsector->ceilingyoffset)/fflatheight;
+ xscale = FixedToFloat(gl_frontsector->ceilingxscale);
+ yscale = FixedToFloat(gl_frontsector->ceilingyscale);
+ scrollx = FixedToFloat(gl_frontsector->ceilingxoffset) / fflatwidth;
+ scrolly = FixedToFloat(gl_frontsector->ceilingyoffset) / fflatheight;
angle = gl_frontsector->ceilingangle;
}
}
- if (angle) // Only needs to be done if there's an altered angle
- {
- tempxsow = flatxref;
- tempytow = flatyref;
-
- anglef = ANG2RAD(InvAngle(angle));
-
- flatxref = (tempxsow * cos(anglef)) - (tempytow * sin(anglef));
- flatyref = (tempxsow * sin(anglef)) + (tempytow * cos(anglef));
- }
+ anglef = ANG2RAD(InvAngle(angle));
#define SETUP3DVERT(vert, vx, vy) {\
/* Hurdler: add scrolling texture on floor/ceiling */\
- if (texflat)\
- {\
- vert->s = (float)((vx) / fflatwidth) + scrollx;\
- vert->t = -(float)((vy) / fflatheight) + scrolly;\
- }\
- else\
- {\
- vert->s = (float)(((vx) / fflatwidth) - flatxref + scrollx);\
- vert->t = (float)(flatyref - ((vy) / fflatheight) + scrolly);\
- }\
+ vert->s = ((vx) / fflatwidth) + (scrollx / xscale);\
+ vert->t = -((vy) / fflatheight) + (scrolly / yscale);\
\
/* Need to rotate before translate */\
if (angle) /* Only needs to be done if there's an altered angle */\
@@ -521,15 +501,18 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
vert->t = (tempxsow * sin(anglef)) + (tempytow * cos(anglef));\
}\
\
- vert->x = (vx);\
- vert->y = height;\
- vert->z = (vy);\
+ vert->s *= xscale;\
+ vert->t *= yscale;\
\
if (slope)\
{\
- fixedheight = P_GetSlopeZAt(slope, FLOAT_TO_FIXED((vx)), FLOAT_TO_FIXED((vy)));\
- vert->y = FIXED_TO_FLOAT(fixedheight);\
+ fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
+ height = FixedToFloat(fixedheight);\
}\
+\
+ vert->x = (vx);\
+ vert->y = height;\
+ vert->z = (vy);\
}
for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++,v3d++,pv++)
@@ -1081,6 +1064,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 +1163,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 +1229,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 +1241,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;
- // 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];
+ texturevpeg += gl_sidedef->rowoffset + gl_sidedef->offsety_bottom;
- grTex = HWR_GetTexture(gl_bottomtexture);
+ // 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 %= 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 +1293,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 +1322,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 +1350,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 +1358,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 +1368,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 +1385,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 +1437,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 +1503,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 +1621,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 +1647,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 +1663,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 +1769,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 +1813,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)
@@ -2715,11 +2708,8 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
INT32 i;
float height = FIXED_TO_FLOAT(fixedheight); // constant y for all points on the convex flat polygon
- float flatxref, flatyref;
float fflatwidth = 64.0f, fflatheight = 64.0f;
- UINT16 flatflag = 63;
-
- boolean texflat = false;
+ float xscale = 1.0f, yscale = 1.0f;
float scrollx = 0.0f, scrolly = 0.0f;
float tempxsow, tempytow, anglef = 0.0f;
@@ -2750,8 +2740,8 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
if (levelflat->type == LEVELFLAT_FLAT)
{
size_t len = W_LumpLength(levelflat->u.flat.lumpnum);
- flatflag = R_GetFlatSize(len) - 1;
- fflatwidth = fflatheight = (float)(flatflag + 1);
+ unsigned flatflag = R_GetFlatSize(len);
+ fflatwidth = fflatheight = (float)flatflag;
}
else
{
@@ -2765,19 +2755,11 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
fflatwidth = levelflat->width;
fflatheight = levelflat->height;
}
- texflat = true;
}
}
else // set no texture
HWR_SetCurrentTexture(NULL);
- // reference point for flat texture coord for each vertex around the polygon
- flatxref = FIXED_TO_FLOAT(polysector->origVerts[0].x);
- flatyref = FIXED_TO_FLOAT(polysector->origVerts[0].y);
-
- flatxref = (float)(((fixed_t)flatxref & (~flatflag)) / fflatwidth);
- flatyref = (float)(((fixed_t)flatyref & (~flatflag)) / fflatheight);
-
// transform
v3d = planeVerts;
@@ -2785,14 +2767,18 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
{
if (!isceiling) // it's a floor
{
- scrollx = FIXED_TO_FLOAT(FOFsector->floorxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(FOFsector->flooryoffset)/fflatheight;
+ xscale = FixedToFloat(FOFsector->floorxscale);
+ yscale = FixedToFloat(FOFsector->flooryscale);
+ scrollx = FixedToFloat(FOFsector->floorxoffset) / fflatwidth;
+ scrolly = FixedToFloat(FOFsector->flooryoffset) / fflatheight;
angle = FOFsector->floorangle;
}
else // it's a ceiling
{
- scrollx = FIXED_TO_FLOAT(FOFsector->ceilingxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(FOFsector->ceilingyoffset)/fflatheight;
+ xscale = FixedToFloat(FOFsector->ceilingxscale);
+ yscale = FixedToFloat(FOFsector->ceilingyscale);
+ scrollx = FixedToFloat(FOFsector->ceilingxoffset) / fflatwidth;
+ scrolly = FixedToFloat(FOFsector->ceilingyoffset) / fflatheight;
angle = FOFsector->ceilingangle;
}
}
@@ -2800,43 +2786,30 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
{
if (!isceiling) // it's a floor
{
- scrollx = FIXED_TO_FLOAT(gl_frontsector->floorxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(gl_frontsector->flooryoffset)/fflatheight;
+ xscale = FixedToFloat(gl_frontsector->floorxscale);
+ yscale = FixedToFloat(gl_frontsector->flooryscale);
+ scrollx = FixedToFloat(gl_frontsector->floorxoffset) / fflatwidth;
+ scrolly = FixedToFloat(gl_frontsector->flooryoffset) / fflatheight;
angle = gl_frontsector->floorangle;
}
else // it's a ceiling
{
- scrollx = FIXED_TO_FLOAT(gl_frontsector->ceilingxoffset)/fflatwidth;
- scrolly = FIXED_TO_FLOAT(gl_frontsector->ceilingyoffset)/fflatheight;
+ xscale = FixedToFloat(gl_frontsector->ceilingxscale);
+ yscale = FixedToFloat(gl_frontsector->ceilingyscale);
+ scrollx = FixedToFloat(gl_frontsector->ceilingxoffset) / fflatwidth;
+ scrolly = FixedToFloat(gl_frontsector->ceilingyoffset) / fflatheight;
angle = gl_frontsector->ceilingangle;
}
}
- if (angle) // Only needs to be done if there's an altered angle
- {
- tempxsow = flatxref;
- tempytow = flatyref;
-
- anglef = ANG2RAD(InvAngle(angle));
-
- flatxref = (tempxsow * cos(anglef)) - (tempytow * sin(anglef));
- flatyref = (tempxsow * sin(anglef)) + (tempytow * cos(anglef));
- }
+ anglef = ANG2RAD(InvAngle(angle));
for (i = 0; i < (INT32)nrPlaneVerts; i++,v3d++)
{
// Go from the polysector's original vertex locations
// Means the flat is offset based on the original vertex locations
- if (texflat)
- {
- v3d->s = (float)(FIXED_TO_FLOAT(polysector->origVerts[i].x) / fflatwidth) + scrollx;
- v3d->t = -(float)(FIXED_TO_FLOAT(polysector->origVerts[i].y) / fflatheight) + scrolly;
- }
- else
- {
- v3d->s = (float)((FIXED_TO_FLOAT(polysector->origVerts[i].x) / fflatwidth) - flatxref + scrollx);
- v3d->t = (float)(flatyref - (FIXED_TO_FLOAT(polysector->origVerts[i].y) / fflatheight) + scrolly);
- }
+ v3d->s = (FixedToFloat(polysector->origVerts[i].x) / fflatwidth) + (scrollx / xscale);
+ v3d->t = -(FixedToFloat(polysector->origVerts[i].y) / fflatheight) + (scrolly / yscale);
// Need to rotate before translate
if (angle) // Only needs to be done if there's an altered angle
@@ -2848,6 +2821,9 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
v3d->t = (tempxsow * sin(anglef)) + (tempytow * cos(anglef));
}
+ v3d->s *= xscale;
+ v3d->t *= yscale;
+
v3d->x = FIXED_TO_FLOAT(polysector->vertices[i]->x);
v3d->y = height;
v3d->z = FIXED_TO_FLOAT(polysector->vertices[i]->y);
diff --git a/src/lua_maplib.c b/src/lua_maplib.c
index 603fc0d8f033825fe89d708a978879adfec5d6e0..0c4ba6fd3e24451d4b3144264bb5c357eb3eea35 100644
--- a/src/lua_maplib.c
+++ b/src/lua_maplib.c
@@ -35,10 +35,14 @@ enum sector_e {
sector_floorpic,
sector_floorxoffset,
sector_flooryoffset,
+ sector_floorxscale,
+ sector_flooryscale,
sector_floorangle,
sector_ceilingpic,
sector_ceilingxoffset,
sector_ceilingyoffset,
+ sector_ceilingxscale,
+ sector_ceilingyscale,
sector_ceilingangle,
sector_lightlevel,
sector_floorlightlevel,
@@ -74,10 +78,14 @@ static const char *const sector_opt[] = {
"floorpic",
"floorxoffset",
"flooryoffset",
+ "floorxscale",
+ "flooryscale",
"floorangle",
"ceilingpic",
"ceilingxoffset",
"ceilingyoffset",
+ "ceilingxscale",
+ "ceilingyscale",
"ceilingangle",
"lightlevel",
"floorlightlevel",
@@ -188,8 +196,16 @@ enum side_e {
side_offsety_top,
side_offsetx_mid,
side_offsety_mid,
+ side_offsetx_bottom,
side_offsetx_bot,
+ side_offsety_bottom,
side_offsety_bot,
+ side_scalex_top,
+ side_scaley_top,
+ side_scalex_mid,
+ side_scaley_mid,
+ side_scalex_bottom,
+ side_scaley_bottom,
side_toptexture,
side_bottomtexture,
side_midtexture,
@@ -208,8 +224,16 @@ static const char *const side_opt[] = {
"offsety_top",
"offsetx_mid",
"offsety_mid",
+ "offsetx_bottom",
"offsetx_bot",
+ "offsety_bottom",
"offsety_bot",
+ "scalex_top",
+ "scaley_top",
+ "scalex_mid",
+ "scaley_mid",
+ "scalex_bottom",
+ "scaley_bottom",
"toptexture",
"bottomtexture",
"midtexture",
@@ -249,8 +273,16 @@ enum ffloor_e {
ffloor_topheight,
ffloor_toppic,
ffloor_toplightlevel,
+ ffloor_topxoffs,
+ ffloor_topyoffs,
+ ffloor_topxscale,
+ ffloor_topyscale,
ffloor_bottomheight,
ffloor_bottompic,
+ ffloor_bottomxoffs,
+ ffloor_bottomyoffs,
+ ffloor_bottomxscale,
+ ffloor_bottomyscale,
ffloor_tslope,
ffloor_bslope,
ffloor_sector,
@@ -275,8 +307,16 @@ static const char *const ffloor_opt[] = {
"topheight",
"toppic",
"toplightlevel",
+ "topxoffs",
+ "topyoffs",
+ "topxscale",
+ "topyscale",
"bottomheight",
"bottompic",
+ "bottomxoffs",
+ "bottomyoffs",
+ "bottomxscale",
+ "bottomyscale",
"t_slope",
"b_slope",
"sector", // secnum pushed as control sector userdata
@@ -656,20 +696,20 @@ static int sector_get(lua_State *L)
return 1;
}
case sector_floorxoffset:
- {
lua_pushfixed(L, sector->floorxoffset);
return 1;
- }
case sector_flooryoffset:
- {
lua_pushfixed(L, sector->flooryoffset);
return 1;
- }
+ case sector_floorxscale:
+ lua_pushfixed(L, sector->floorxscale);
+ return 1;
+ case sector_flooryscale:
+ lua_pushfixed(L, sector->flooryscale);
+ return 1;
case sector_floorangle:
- {
lua_pushangle(L, sector->floorangle);
return 1;
- }
case sector_ceilingpic: // ceilingpic
{
levelflat_t *levelflat = &levelflats[sector->ceilingpic];
@@ -680,20 +720,20 @@ static int sector_get(lua_State *L)
return 1;
}
case sector_ceilingxoffset:
- {
lua_pushfixed(L, sector->ceilingxoffset);
return 1;
- }
case sector_ceilingyoffset:
- {
lua_pushfixed(L, sector->ceilingyoffset);
return 1;
- }
+ case sector_ceilingxscale:
+ lua_pushfixed(L, sector->ceilingxscale);
+ return 1;
+ case sector_ceilingyscale:
+ lua_pushfixed(L, sector->ceilingyscale);
+ return 1;
case sector_ceilingangle:
- {
lua_pushangle(L, sector->ceilingangle);
return 1;
- }
case sector_lightlevel:
lua_pushinteger(L, sector->lightlevel);
return 1;
@@ -845,6 +885,12 @@ static int sector_set(lua_State *L)
case sector_flooryoffset:
sector->flooryoffset = luaL_checkfixed(L, 3);
break;
+ case sector_floorxscale:
+ sector->floorxscale = luaL_checkfixed(L, 3);
+ break;
+ case sector_flooryscale:
+ sector->flooryscale = luaL_checkfixed(L, 3);
+ break;
case sector_floorangle:
sector->floorangle = luaL_checkangle(L, 3);
break;
@@ -857,6 +903,12 @@ static int sector_set(lua_State *L)
case sector_ceilingyoffset:
sector->ceilingyoffset = luaL_checkfixed(L, 3);
break;
+ case sector_ceilingxscale:
+ sector->ceilingxscale = luaL_checkfixed(L, 3);
+ break;
+ case sector_ceilingyscale:
+ sector->ceilingyscale = luaL_checkfixed(L, 3);
+ break;
case sector_ceilingangle:
sector->ceilingangle = luaL_checkangle(L, 3);
break;
@@ -1210,11 +1262,31 @@ static int side_get(lua_State *L)
case side_offsety_mid:
lua_pushfixed(L, side->offsety_mid);
return 1;
+ case side_offsetx_bottom:
case side_offsetx_bot:
- lua_pushfixed(L, side->offsetx_bot);
+ lua_pushfixed(L, side->offsetx_bottom);
return 1;
+ case side_offsety_bottom:
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_bottom:
+ lua_pushfixed(L, side->scalex_bottom);
+ return 1;
+ case side_scaley_bottom:
+ lua_pushfixed(L, side->scaley_bottom);
return 1;
case side_toptexture:
lua_pushinteger(L, side->toptexture);
@@ -1302,10 +1374,30 @@ 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);
+ case side_offsetx_bottom:
+ side->offsetx_bottom = luaL_checkfixed(L, 3);
break;
case side_offsety_bot:
- side->offsety_bot = luaL_checkfixed(L, 3);
+ case side_offsety_bottom:
+ 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_bottom:
+ side->scalex_bottom = luaL_checkfixed(L, 3);
+ break;
+ case side_scaley_bottom:
+ side->scaley_bottom = luaL_checkfixed(L, 3);
break;
case side_toptexture:
side->toptexture = luaL_checkinteger(L, 3);
@@ -2122,6 +2214,18 @@ static int ffloor_get(lua_State *L)
case ffloor_toplightlevel:
lua_pushinteger(L, *ffloor->toplightlevel);
return 1;
+ case ffloor_topxoffs:
+ lua_pushfixed(L, *ffloor->topxoffs);
+ return 1;
+ case ffloor_topyoffs:
+ lua_pushfixed(L, *ffloor->topyoffs);
+ return 1;
+ case ffloor_topxscale:
+ lua_pushfixed(L, *ffloor->topxscale);
+ return 1;
+ case ffloor_topyscale:
+ lua_pushfixed(L, *ffloor->topyscale);
+ return 1;
case ffloor_bottomheight:
lua_pushfixed(L, *ffloor->bottomheight);
return 1;
@@ -2133,6 +2237,18 @@ static int ffloor_get(lua_State *L)
lua_pushlstring(L, levelflat->name, i);
return 1;
}
+ case ffloor_bottomxoffs:
+ lua_pushfixed(L, *ffloor->bottomxoffs);
+ return 1;
+ case ffloor_bottomyoffs:
+ lua_pushfixed(L, *ffloor->bottomyoffs);
+ return 1;
+ case ffloor_bottomxscale:
+ lua_pushfixed(L, *ffloor->bottomxscale);
+ return 1;
+ case ffloor_bottomyscale:
+ lua_pushfixed(L, *ffloor->bottomyscale);
+ return 1;
case ffloor_tslope:
LUA_PushUserdata(L, *ffloor->t_slope, META_SLOPE);
return 1;
@@ -2317,6 +2433,18 @@ static int ffloor_set(lua_State *L)
case ffloor_toplightlevel:
*ffloor->toplightlevel = (INT16)luaL_checkinteger(L, 3);
break;
+ case ffloor_topxoffs:
+ *ffloor->topxoffs = luaL_checkfixed(L, 3);
+ break;
+ case ffloor_topyoffs:
+ *ffloor->topyoffs = luaL_checkfixed(L, 3);
+ break;
+ case ffloor_topxscale:
+ *ffloor->topxscale = luaL_checkfixed(L, 3);
+ break;
+ case ffloor_topyscale:
+ *ffloor->topyscale = luaL_checkfixed(L, 3);
+ break;
case ffloor_bottomheight: { // bottomheight
boolean flag;
fixed_t lastpos = *ffloor->bottomheight;
@@ -2335,6 +2463,18 @@ static int ffloor_set(lua_State *L)
case ffloor_bottompic:
*ffloor->bottompic = P_AddLevelFlatRuntime(luaL_checkstring(L, 3));
break;
+ case ffloor_bottomxoffs:
+ *ffloor->bottomxoffs = luaL_checkfixed(L, 3);
+ break;
+ case ffloor_bottomyoffs:
+ *ffloor->bottomyoffs = luaL_checkfixed(L, 3);
+ break;
+ case ffloor_bottomxscale:
+ *ffloor->bottomxscale = luaL_checkfixed(L, 3);
+ break;
+ case ffloor_bottomyscale:
+ *ffloor->bottomyscale = luaL_checkfixed(L, 3);
+ break;
case ffloor_fofflags: {
ffloortype_e oldflags = ffloor->fofflags; // store FOF's old flags
ffloor->fofflags = luaL_checkinteger(L, 3);
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 94ce35f5ad0eb7cd3f0c2633548df14bdebd2292..8c74ebef4815cd535c16436b682efcdd769b5f42 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -867,24 +867,47 @@ static void P_NetUnArchiveWaypoints(void)
#define SD_TRIGGERTAG 0x02
#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
-
-// 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
+#define SD_FXSCALE 0x10
+#define SD_FYSCALE 0x20
+#define SD_CXSCALE 0x40
+#define SD_CYSCALE 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
+
+// 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)
{
@@ -1035,6 +1058,14 @@ static void ArchiveSectors(void)
diff2 |= SD_CXOFFS;
if (ss->ceilingyoffset != spawnss->ceilingyoffset)
diff2 |= SD_CYOFFS;
+ if (ss->floorxscale != spawnss->floorxscale)
+ diff2 |= SD_FXSCALE;
+ if (ss->flooryscale != spawnss->flooryscale)
+ diff2 |= SD_FYSCALE;
+ if (ss->ceilingxscale != spawnss->ceilingxscale)
+ diff2 |= SD_CXSCALE;
+ if (ss->ceilingyscale != spawnss->ceilingyscale)
+ diff2 |= SD_CYSCALE;
if (ss->floorangle != spawnss->floorangle)
diff2 |= SD_FLOORANG;
if (ss->ceilingangle != spawnss->ceilingangle)
@@ -1145,6 +1176,14 @@ static void ArchiveSectors(void)
WRITEUINT8(save_p, ss->triggerer);
if (diff4 & SD_GRAVITY)
WRITEFIXED(save_p, ss->gravity);
+ if (diff4 & SD_FXSCALE)
+ WRITEFIXED(save_p, ss->floorxscale);
+ if (diff4 & SD_FYSCALE)
+ WRITEFIXED(save_p, ss->flooryscale);
+ if (diff4 & SD_CXSCALE)
+ WRITEFIXED(save_p, ss->ceilingxscale);
+ if (diff4 & SD_CYSCALE)
+ WRITEFIXED(save_p, ss->ceilingyscale);
if (diff & SD_FFLOORS)
ArchiveFFloors(ss);
}
@@ -1266,24 +1305,117 @@ static void UnArchiveSectors(void)
sectors[i].triggerer = READUINT8(save_p);
if (diff4 & SD_GRAVITY)
sectors[i].gravity = READFIXED(save_p);
+ if (diff4 & SD_FXSCALE)
+ sectors[i].floorxscale = READFIXED(save_p);
+ if (diff4 & SD_FYSCALE)
+ sectors[i].flooryscale = READFIXED(save_p);
+ if (diff4 & SD_CXSCALE)
+ sectors[i].ceilingxscale = READFIXED(save_p);
+ if (diff4 & SD_CYSCALE)
+ sectors[i].ceilingyscale = READFIXED(save_p);
if (diff & SD_FFLOORS)
UnArchiveFFloors(§ors[i]);
}
}
+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 +1424,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 +1480,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 +1551,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 +1584,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]]);
}
}
diff --git a/src/p_setup.c b/src/p_setup.c
index 3e18c5b2dc15e017bb2e3b001929f3dc95cbce40..6974eab53213ca27c696ce96c38cbad9facd7b08 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -1055,6 +1055,9 @@ static void P_LoadSectors(UINT8 *data)
ss->floorxoffset = ss->flooryoffset = 0;
ss->ceilingxoffset = ss->ceilingyoffset = 0;
+ ss->floorxscale = ss->flooryscale = FRACUNIT;
+ ss->ceilingxscale = ss->ceilingyscale = FRACUNIT;
+
ss->floorangle = ss->ceilingangle = 0;
ss->floorlightlevel = ss->ceilinglightlevel = 0;
@@ -1352,8 +1355,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));
@@ -1693,6 +1699,14 @@ static void ParseTextmapSectorParameter(UINT32 i, const char *param, const char
sectors[i].ceilingxoffset = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "ypanningceiling"))
sectors[i].ceilingyoffset = FLOAT_TO_FIXED(atof(val));
+ else if (fastcmp(param, "xscalefloor"))
+ sectors[i].floorxscale = FLOAT_TO_FIXED(atof(val));
+ else if (fastcmp(param, "yscalefloor"))
+ sectors[i].flooryscale = FLOAT_TO_FIXED(atof(val));
+ else if (fastcmp(param, "xscaleceiling"))
+ sectors[i].ceilingxscale = FLOAT_TO_FIXED(atof(val));
+ else if (fastcmp(param, "yscaleceiling"))
+ sectors[i].ceilingyscale = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "rotationfloor"))
sectors[i].floorangle = FixedAngle(FLOAT_TO_FIXED(atof(val)));
else if (fastcmp(param, "rotationceiling"))
@@ -1888,13 +1902,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 +2625,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)
@@ -2658,6 +2696,14 @@ static void P_WriteTextmap(void)
fprintf(f, "xpanningceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingxoffset));
if (tempsec.ceilingyoffset != 0)
fprintf(f, "ypanningceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingyoffset));
+ if (tempsec.floorxscale != 0)
+ fprintf(f, "xscalefloor = %f;\n", FIXED_TO_FLOAT(tempsec.floorxscale));
+ if (tempsec.flooryscale != 0)
+ fprintf(f, "yscalefloor = %f;\n", FIXED_TO_FLOAT(tempsec.flooryscale));
+ if (tempsec.ceilingxscale != 0)
+ fprintf(f, "xscaleceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingxscale));
+ if (tempsec.ceilingyscale != 0)
+ fprintf(f, "yscaleceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingyscale));
if (wsectors[i].floorangle != 0)
fprintf(f, "rotationfloor = %f;\n", FIXED_TO_FLOAT(AngleFixed(wsectors[i].floorangle)));
if (wsectors[i].ceilingangle != 0)
@@ -2893,6 +2939,9 @@ static void P_LoadTextmap(void)
sc->floorxoffset = sc->flooryoffset = 0;
sc->ceilingxoffset = sc->ceilingyoffset = 0;
+ sc->floorxscale = sc->flooryscale = FRACUNIT;
+ sc->ceilingxscale = sc->ceilingyscale = FRACUNIT;
+
sc->floorangle = sc->ceilingangle = 0;
sc->floorlightlevel = sc->ceilinglightlevel = 0;
@@ -2979,8 +3028,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 +3357,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 +3599,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
}
diff --git a/src/p_spec.c b/src/p_spec.c
index 7dc16378ee9191499075c724984e76c8cc9dd9e5..4263a4fc7b57265915440ef13fd4625a4dd5a293 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -5605,6 +5605,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I
fflr->bottompic = &sec2->floorpic;
fflr->bottomxoffs = &sec2->floorxoffset;
fflr->bottomyoffs = &sec2->flooryoffset;
+ fflr->bottomxscale = &sec2->floorxscale;
+ fflr->bottomyscale = &sec2->flooryscale;
fflr->bottomangle = &sec2->floorangle;
// Add the ceiling
@@ -5613,6 +5615,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I
fflr->toplightlevel = &sec2->lightlevel;
fflr->topxoffs = &sec2->ceilingxoffset;
fflr->topyoffs = &sec2->ceilingyoffset;
+ fflr->topxscale = &sec2->ceilingxscale;
+ fflr->topyscale = &sec2->ceilingyscale;
fflr->topangle = &sec2->ceilingangle;
// Add slopes
diff --git a/src/r_bsp.c b/src/r_bsp.c
index 42e050adf831f15a7b3e653c57e265cab781b6cc..d99de5981ba789395347a01ae28ad14f4c68bb0d 100644
--- a/src/r_bsp.c
+++ b/src/r_bsp.c
@@ -277,6 +277,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = s->floorpic;
tempsec->floorxoffset = s->floorxoffset;
tempsec->flooryoffset = s->flooryoffset;
+ tempsec->floorxscale = s->floorxscale;
+ tempsec->flooryscale = s->flooryscale;
tempsec->floorangle = s->floorangle;
if (underwater)
@@ -287,6 +289,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->ceilingpic = tempsec->floorpic;
tempsec->ceilingxoffset = tempsec->floorxoffset;
tempsec->ceilingyoffset = tempsec->flooryoffset;
+ tempsec->ceilingxscale = tempsec->floorxscale;
+ tempsec->ceilingyscale = tempsec->flooryscale;
tempsec->ceilingangle = tempsec->floorangle;
}
else
@@ -294,6 +298,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->ceilingpic = s->ceilingpic;
tempsec->ceilingxoffset = s->ceilingxoffset;
tempsec->ceilingyoffset = s->ceilingyoffset;
+ tempsec->ceilingxscale = s->ceilingxscale;
+ tempsec->ceilingyscale = s->ceilingyscale;
tempsec->ceilingangle = s->ceilingangle;
}
}
@@ -317,6 +323,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = tempsec->ceilingpic = s->ceilingpic;
tempsec->floorxoffset = tempsec->ceilingxoffset = s->ceilingxoffset;
tempsec->flooryoffset = tempsec->ceilingyoffset = s->ceilingyoffset;
+ tempsec->floorxscale = tempsec->ceilingxscale = s->ceilingxscale;
+ tempsec->flooryscale = tempsec->ceilingyscale = s->ceilingyscale;
tempsec->floorangle = tempsec->ceilingangle = s->ceilingangle;
if (s->floorpic == skyflatnum) // SKYFIX?
@@ -325,6 +333,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = tempsec->ceilingpic;
tempsec->floorxoffset = tempsec->ceilingxoffset;
tempsec->flooryoffset = tempsec->ceilingyoffset;
+ tempsec->floorxscale = tempsec->ceilingxscale;
+ tempsec->flooryscale = tempsec->ceilingyscale;
tempsec->floorangle = tempsec->ceilingangle;
}
else
@@ -333,6 +343,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = s->floorpic;
tempsec->floorxoffset = s->floorxoffset;
tempsec->flooryoffset = s->flooryoffset;
+ tempsec->floorxscale = s->floorxscale;
+ tempsec->flooryscale = s->flooryscale;
tempsec->floorangle = s->floorangle;
}
@@ -362,12 +374,16 @@ boolean R_IsEmptyLine(seg_t *line, sector_t *front, sector_t *back)
&& back->c_slope == front->c_slope
&& back->lightlevel == front->lightlevel
&& !line->sidedef->midtexture
- // Check offsets too!
+ // Check offsets and scale too!
&& back->floorxoffset == front->floorxoffset
&& back->flooryoffset == front->flooryoffset
+ && back->floorxscale == front->floorxscale
+ && back->flooryscale == front->flooryscale
&& back->floorangle == front->floorangle
&& back->ceilingxoffset == front->ceilingxoffset
&& back->ceilingyoffset == front->ceilingyoffset
+ && back->ceilingxscale == front->ceilingxscale
+ && back->ceilingyscale == front->ceilingyscale
&& back->ceilingangle == front->ceilingangle
// Consider altered lighting.
&& back->floorlightlevel == front->floorlightlevel
@@ -909,7 +925,9 @@ static void R_Subsector(size_t num)
|| (frontsector->heightsec != -1 && sectors[frontsector->heightsec].ceilingpic == skyflatnum))
{
floorplane = R_FindPlane(frontsector->floorheight, frontsector->floorpic, floorlightlevel,
- frontsector->floorxoffset, frontsector->flooryoffset, frontsector->floorangle, floorcolormap, NULL, NULL, frontsector->f_slope);
+ frontsector->floorxoffset, frontsector->flooryoffset,
+ frontsector->floorxscale, frontsector->flooryscale, frontsector->floorangle,
+ floorcolormap, NULL, NULL, frontsector->f_slope);
}
else
floorplane = NULL;
@@ -918,8 +936,9 @@ static void R_Subsector(size_t num)
|| frontsector->ceilingpic == skyflatnum
|| (frontsector->heightsec != -1 && sectors[frontsector->heightsec].floorpic == skyflatnum))
{
- ceilingplane = R_FindPlane(frontsector->ceilingheight, frontsector->ceilingpic,
- ceilinglightlevel, frontsector->ceilingxoffset, frontsector->ceilingyoffset, frontsector->ceilingangle,
+ ceilingplane = R_FindPlane(frontsector->ceilingheight, frontsector->ceilingpic, ceilinglightlevel,
+ frontsector->ceilingxoffset, frontsector->ceilingyoffset,
+ frontsector->ceilingxscale, frontsector->ceilingyscale, frontsector->ceilingangle,
ceilingcolormap, NULL, NULL, frontsector->c_slope);
}
else
@@ -962,8 +981,9 @@ static void R_Subsector(size_t num)
viewz < heightcheck);
ffloor[numffloors].plane = R_FindPlane(*rover->bottomheight, *rover->bottompic,
- *frontsector->lightlist[light].lightlevel, *rover->bottomxoffs,
- *rover->bottomyoffs, *rover->bottomangle, *frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->b_slope);
+ *frontsector->lightlist[light].lightlevel, *rover->bottomxoffs, *rover->bottomyoffs,
+ *rover->bottomxscale, *rover->bottomyscale, *rover->bottomangle,
+ *frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->b_slope);
ffloor[numffloors].slope = *rover->b_slope;
@@ -991,7 +1011,8 @@ static void R_Subsector(size_t num)
light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck);
ffloor[numffloors].plane = R_FindPlane(*rover->topheight, *rover->toppic,
- *frontsector->lightlist[light].lightlevel, *rover->topxoffs, *rover->topyoffs, *rover->topangle,
+ *frontsector->lightlist[light].lightlevel, *rover->topxoffs, *rover->topyoffs,
+ *rover->topxscale, *rover->topyscale, *rover->topangle,
*frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->t_slope);
ffloor[numffloors].slope = *rover->t_slope;
@@ -1033,7 +1054,9 @@ static void R_Subsector(size_t num)
{
light = R_GetPlaneLight(frontsector, polysec->floorheight, viewz < polysec->floorheight);
ffloor[numffloors].plane = R_FindPlane(polysec->floorheight, polysec->floorpic,
- (light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel), polysec->floorxoffset, polysec->flooryoffset,
+ (light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel),
+ polysec->floorxoffset, polysec->flooryoffset,
+ polysec->floorxscale, polysec->flooryscale,
polysec->floorangle-po->angle,
(light == -1 ? frontsector->extra_colormap : *frontsector->lightlist[light].extra_colormap), NULL, po,
NULL); // will ffloors be slopable eventually?
@@ -1057,7 +1080,10 @@ static void R_Subsector(size_t num)
{
light = R_GetPlaneLight(frontsector, polysec->floorheight, viewz < polysec->floorheight);
ffloor[numffloors].plane = R_FindPlane(polysec->ceilingheight, polysec->ceilingpic,
- (light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel), polysec->ceilingxoffset, polysec->ceilingyoffset, polysec->ceilingangle-po->angle,
+ (light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel),
+ polysec->ceilingxoffset, polysec->ceilingyoffset,
+ polysec->ceilingxscale, polysec->ceilingyscale,
+ polysec->ceilingangle-po->angle,
(light == -1 ? frontsector->extra_colormap : *frontsector->lightlist[light].extra_colormap), NULL, po,
NULL); // will ffloors be slopable eventually?
diff --git a/src/r_defs.h b/src/r_defs.h
index 4cb8c1769699396b84f64a3c68adc95b54e94f60..bce045ab47d910513ef98313e6b4ed24b36026ef 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -218,12 +218,16 @@ typedef struct ffloor_s
INT16 *toplightlevel;
fixed_t *topxoffs;
fixed_t *topyoffs;
+ fixed_t *topxscale;
+ fixed_t *topyscale;
angle_t *topangle;
fixed_t *bottomheight;
INT32 *bottompic;
fixed_t *bottomxoffs;
fixed_t *bottomyoffs;
+ fixed_t *bottomxscale;
+ fixed_t *bottomyscale;
angle_t *bottomangle;
// Pointers to pointers. Yup.
@@ -429,6 +433,10 @@ typedef struct sector_s
fixed_t floorxoffset, flooryoffset;
fixed_t ceilingxoffset, ceilingyoffset;
+ // floor and ceiling texture scale
+ fixed_t floorxscale, flooryscale;
+ fixed_t ceilingxscale, ceilingyscale;
+
// flat angle
angle_t floorangle;
angle_t ceilingangle;
@@ -564,8 +572,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 +770,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;
diff --git a/src/r_plane.c b/src/r_plane.c
index 29ce26b292e5ea529d937aded0028e41a8d294ba..9c87ecbe42f7020d86e47ab294229426cdb5ae23 100644
--- a/src/r_plane.c
+++ b/src/r_plane.c
@@ -83,11 +83,6 @@ static fixed_t planeheight;
fixed_t yslopetab[MAXVIDHEIGHT*16];
fixed_t *yslope;
-fixed_t cachedheight[MAXVIDHEIGHT];
-fixed_t cacheddistance[MAXVIDHEIGHT];
-fixed_t cachedxstep[MAXVIDHEIGHT];
-fixed_t cachedystep[MAXVIDHEIGHT];
-
static fixed_t xoffs, yoffs;
static floatv3_t ds_slope_origin, ds_slope_u, ds_slope_v;
@@ -159,37 +154,28 @@ static void R_MapPlane(INT32 y, INT32 x1, INT32 x2)
planecos = FINECOSINE(angle);
planesin = FINESINE(angle);
- if (planeheight != cachedheight[y])
- {
- cachedheight[y] = planeheight;
- cacheddistance[y] = distance = FixedMul(planeheight, yslope[y]);
- span = abs(centery - y);
-
- if (span) // Don't divide by zero
- {
- ds_xstep = FixedMul(planesin, planeheight) / span;
- ds_ystep = FixedMul(planecos, planeheight) / span;
- }
- else
- ds_xstep = ds_ystep = FRACUNIT;
+ // [RH] Notice that I dumped the caching scheme used by Doom.
+ // It did not offer any appreciable speedup.
+ distance = FixedMul(planeheight, yslope[y]);
+ span = abs(centery - y);
- cachedxstep[y] = ds_xstep;
- cachedystep[y] = ds_ystep;
- }
- else
+ if (span) // Don't divide by zero
{
- distance = cacheddistance[y];
- ds_xstep = cachedxstep[y];
- ds_ystep = cachedystep[y];
+ ds_xstep = FixedMul(planesin, planeheight) / span;
+ ds_ystep = FixedMul(planecos, planeheight) / span;
+ ds_xstep = FixedMul(currentplane->xscale, ds_xstep);
+ ds_ystep = FixedMul(currentplane->yscale, ds_ystep);
}
+ else
+ ds_xstep = ds_ystep = FRACUNIT;
// [RH] Instead of using the xtoviewangle array, I calculated the fractional values
// at the middle of the screen, then used the calculated ds_xstep and ds_ystep
// to step from those to the proper texture coordinate to start drawing at.
// That way, the texture coordinate is always calculated by its position
// on the screen and not by its position relative to the edge of the visplane.
- ds_xfrac = xoffs + FixedMul(planecos, distance) + (x1 - centerx) * ds_xstep;
- ds_yfrac = yoffs - FixedMul(planesin, distance) + (x1 - centerx) * ds_ystep;
+ ds_xfrac = xoffs + FixedMul(currentplane->xscale, FixedMul(planecos, distance)) + (x1 - centerx) * ds_xstep;
+ ds_yfrac = yoffs - FixedMul(currentplane->yscale, FixedMul(planesin, distance)) + (x1 - centerx) * ds_ystep;
// Water ripple effect
if (planeripple.active)
@@ -275,10 +261,7 @@ static void R_MapFogPlane(INT32 y, INT32 x1, INT32 x2)
if (x1 >= vid.width)
x1 = vid.width - 1;
- if (planeheight != cachedheight[y])
- distance = FixedMul(planeheight, yslope[y]);
- else
- distance = cacheddistance[y];
+ distance = FixedMul(planeheight, yslope[y]);
pindex = distance >> LIGHTZSHIFT;
if (pindex >= MAXLIGHTZ)
@@ -361,9 +344,6 @@ void R_ClearPlanes(void)
{
freehead = &(*freehead)->next;
}
-
- // texture calculation
- memset(cachedheight, 0, sizeof (cachedheight));
}
static visplane_t *new_visplane(unsigned hash)
@@ -391,7 +371,8 @@ static visplane_t *new_visplane(unsigned hash)
// If not, allocates another of them.
//
visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
- fixed_t xoff, fixed_t yoff, angle_t plangle, extracolormap_t *planecolormap,
+ fixed_t xoff, fixed_t yoff, fixed_t xscale, fixed_t yscale,
+ angle_t plangle, extracolormap_t *planecolormap,
ffloor_t *pfloor, polyobj_t *polyobj, pslope_t *slope)
{
visplane_t *check;
@@ -399,8 +380,9 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
if (!slope) // Don't mess with this right now if a slope is involved
{
- xoff += viewx;
- yoff -= viewy;
+ xoff += FixedMul(viewx, xscale);
+ yoff -= FixedMul(viewy, yscale);
+
if (plangle != 0)
{
// Add the view offset, rotated by the plane angle.
@@ -441,16 +423,16 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
hash = visplane_hash(picnum, lightlevel, height);
for (check = visplanes[hash]; check; check = check->next)
{
- if (polyobj != check->polyobj)
- continue;
if (height == check->height && picnum == check->picnum
&& lightlevel == check->lightlevel
&& xoff == check->xoffs && yoff == check->yoffs
+ && xscale == check->xscale && yscale == check->yscale
&& planecolormap == check->extra_colormap
&& check->viewx == viewx && check->viewy == viewy && check->viewz == viewz
&& check->viewangle == viewangle
&& check->plangle == plangle
- && check->slope == slope)
+ && check->slope == slope
+ && check->polyobj == polyobj)
{
return check;
}
@@ -470,6 +452,8 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
check->maxx = -1;
check->xoffs = xoff;
check->yoffs = yoff;
+ check->xscale = xscale;
+ check->yscale = yscale;
check->extra_colormap = planecolormap;
check->ffloor = pfloor;
check->viewx = viewx;
@@ -546,6 +530,8 @@ visplane_t *R_CheckPlane(visplane_t *pl, INT32 start, INT32 stop)
new_pl->lightlevel = pl->lightlevel;
new_pl->xoffs = pl->xoffs;
new_pl->yoffs = pl->yoffs;
+ new_pl->xscale = pl->xscale;
+ new_pl->yscale = pl->yscale;
new_pl->extra_colormap = pl->extra_colormap;
new_pl->ffloor = pl->ffloor;
new_pl->viewx = pl->viewx;
@@ -812,7 +798,16 @@ void R_SetTiltedSpan(INT32 span)
static void R_SetSlopePlaneVectors(visplane_t *pl, INT32 y, fixed_t xoff, fixed_t yoff)
{
R_SetTiltedSpan(y);
- R_SetSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz, xoff, yoff, pl->viewangle, pl->plangle);
+
+ if (pl->xscale != FRACUNIT || pl->yscale != FRACUNIT)
+ {
+ R_SetScaledSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz,
+ FixedDiv(FRACUNIT, pl->xscale), FixedDiv(FRACUNIT, pl->yscale),
+ FixedDiv(xoff, pl->xscale), FixedDiv(yoff, pl->yscale), pl->viewangle, pl->plangle);
+ }
+ else
+ R_SetSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz, xoff, yoff, pl->viewangle, pl->plangle);
+
R_CalculateSlopeVectors();
}
@@ -1000,13 +995,6 @@ void R_DrawSinglePlane(visplane_t *pl)
}
}
- // Don't mess with angle on slopes! We'll handle this ourselves later
- if (!pl->slope && viewangle != pl->viewangle+pl->plangle)
- {
- memset(cachedheight, 0, sizeof (cachedheight));
- viewangle = pl->viewangle+pl->plangle;
- }
-
mapfunc = R_MapPlane;
if (ds_solidcolor)
@@ -1043,7 +1031,7 @@ void R_DrawSinglePlane(visplane_t *pl)
{
mapfunc = R_MapTiltedPlane;
- if (!pl->plangle && !ds_solidcolor)
+ if (!pl->plangle && !ds_solidcolor && pl->xscale == FRACUNIT && pl->yscale == FRACUNIT)
{
if (ds_powersoftwo)
R_AdjustSlopeCoordinates(&pl->slope->o);
diff --git a/src/r_plane.h b/src/r_plane.h
index 917e8b041b75775016dbc2a1e10b8cc6ad7a3778..38d49d5dbf9eddb836957e7593b12e9fda050b39 100644
--- a/src/r_plane.h
+++ b/src/r_plane.h
@@ -49,6 +49,7 @@ typedef struct visplane_s
INT32 high, low; // R_PlaneBounds should set these.
fixed_t xoffs, yoffs; // Scrolling flats.
+ fixed_t xscale, yscale;
struct ffloor_s *ffloor;
polyobj_t *polyobj;
@@ -62,10 +63,6 @@ extern visplane_t *ceilingplane;
// Visplane related.
extern INT16 floorclip[MAXVIDWIDTH], ceilingclip[MAXVIDWIDTH];
extern fixed_t frontscale[MAXVIDWIDTH], yslopetab[MAXVIDHEIGHT*16];
-extern fixed_t cachedheight[MAXVIDHEIGHT];
-extern fixed_t cacheddistance[MAXVIDHEIGHT];
-extern fixed_t cachedxstep[MAXVIDHEIGHT];
-extern fixed_t cachedystep[MAXVIDHEIGHT];
extern fixed_t *yslope;
extern lighttable_t **planezlight;
@@ -75,8 +72,8 @@ void R_ClearPlanes(void);
void R_ClearFFloorClips (void);
void R_DrawPlanes(void);
-visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel, fixed_t xoff, fixed_t yoff, angle_t plangle,
- extracolormap_t *planecolormap, ffloor_t *ffloor, polyobj_t *polyobj, pslope_t *slope);
+visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel, fixed_t xoff, fixed_t yoff, fixed_t xscale, fixed_t yscale,
+ angle_t plangle, extracolormap_t *planecolormap, ffloor_t *ffloor, polyobj_t *polyobj, pslope_t *slope);
visplane_t *R_CheckPlane(visplane_t *pl, INT32 start, INT32 stop);
void R_ExpandPlane(visplane_t *pl, INT32 start, INT32 stop);
void R_PlaneBounds(visplane_t *plane);
diff --git a/src/r_segs.c b/src/r_segs.c
index 019a0d5c6a9f7e316d984546e7cb7c7cd5c9bae5..ecc49fbc23ec80e7100c82dbd957fb453735f643 100644
--- a/src/r_segs.c
+++ b/src/r_segs.c
@@ -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 = 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 = sidedef->rowoffset + sidedef->offsety_mid;
+
+ if (lineflags & ML_DONTPEGBOTTOM)
{
- 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)
+ if (maskedtexturecol)
+ maskedtexturecol[rw_x] = texturecolumn + rw_offsetx;
+
+ 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)
{
- // save texturecol
- // for backdrawing of masked mid texture
- maskedtexturecol[rw_x] = texturecolumn + rw_offset_mid;
-
- if (maskedtextureheight != NULL) {
- maskedtextureheight[rw_x] = (curline->linedef->flags & ML_MIDPEG) ?
- max(rw_midtexturemid, rw_midtextureback) :
- min(rw_midtexturemid, rw_midtextureback);
+ 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;
@@ -1901,6 +1981,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
//SoM: 3/22/2000: Check floor x and y offsets.
|| backsector->floorxoffset != frontsector->floorxoffset
|| backsector->flooryoffset != frontsector->flooryoffset
+ || backsector->floorxscale != frontsector->floorxscale
+ || backsector->flooryscale != frontsector->flooryscale
|| backsector->floorangle != frontsector->floorangle
//SoM: 3/22/2000: Prevents bleeding.
|| (frontsector->heightsec != -1 && frontsector->floorpic != skyflatnum)
@@ -1934,6 +2016,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
//SoM: 3/22/2000: Check floor x and y offsets.
|| backsector->ceilingxoffset != frontsector->ceilingxoffset
|| backsector->ceilingyoffset != frontsector->ceilingyoffset
+ || backsector->ceilingxscale != frontsector->ceilingxscale
+ || backsector->ceilingyscale != frontsector->ceilingyscale
|| backsector->ceilingangle != frontsector->ceilingangle
//SoM: 3/22/2000: Prevents bleeding.
|| (frontsector->heightsec != -1 && frontsector->ceilingpic != skyflatnum)
@@ -1962,16 +2046,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 +2084,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 +2095,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 +2118,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;
+ rw_toptexturemid += toprowoffset;
+ rw_bottomtexturemid += botrowoffset;
+ // allocate space for masked texture tables
R_AllocTextureColumnTables(rw_stopx - start);
- // allocate space for masked texture tables
if (frontsector && backsector && !Tag_Compare(&frontsector->tags, &backsector->tags) && (backsector->ffloors || frontsector->ffloors))
{
ffloor_t *rover;
@@ -2031,10 +2144,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 +2325,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 +2349,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 +2373,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 +2389,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 +2415,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 +2448,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.
diff --git a/src/r_splats.c b/src/r_splats.c
index 0b482d7988cc0e3a32f719a0f84a272fdf63d2f3..9bfaa6b51156d0752c4d515e57ceb9b03b8ea9d8 100644
--- a/src/r_splats.c
+++ b/src/r_splats.c
@@ -391,8 +391,6 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
if (pSplat->angle)
{
- memset(cachedheight, 0, sizeof(cachedheight));
-
// Add the view offset, rotated by the plane angle.
fixed_t a = -pSplat->verts[0].x + vis->viewpoint.x;
fixed_t b = -pSplat->verts[0].y + vis->viewpoint.y;
@@ -547,29 +545,18 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
angle_t planecos = FINECOSINE(angle);
angle_t planesin = FINESINE(angle);
- if (planeheight != cachedheight[y])
- {
- cachedheight[y] = planeheight;
- distance = cacheddistance[y] = FixedMul(planeheight, yslope[y]);
- span = abs(centery - y);
-
- if (span) // Don't divide by zero
- {
- xstep = FixedMul(planesin, planeheight) / span;
- ystep = FixedMul(planecos, planeheight) / span;
- }
- else
- xstep = ystep = FRACUNIT;
+ // [RH] Notice that I dumped the caching scheme used by Doom.
+ // It did not offer any appreciable speedup.
+ distance = FixedMul(planeheight, yslope[y]);
+ span = abs(centery - y);
- cachedxstep[y] = xstep;
- cachedystep[y] = ystep;
- }
- else
+ if (span) // Don't divide by zero
{
- distance = cacheddistance[y];
- xstep = cachedxstep[y];
- ystep = cachedystep[y];
+ xstep = FixedMul(planesin, planeheight) / span;
+ ystep = FixedMul(planecos, planeheight) / span;
}
+ else
+ xstep = ystep = FRACUNIT;
ds_xstep = FixedDiv(xstep, pSplat->xscale);
ds_ystep = FixedDiv(ystep, pSplat->yscale);
@@ -586,9 +573,6 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
rastertab[y].minx = INT32_MAX;
rastertab[y].maxx = INT32_MIN;
}
-
- if (!ds_solidcolor && pSplat->angle && !pSplat->slope)
- memset(cachedheight, 0, sizeof(cachedheight));
}
static void prepare_rastertab(void)