mirror of
https://git.do.srb2.org/STJr/SRB2.git
synced 2025-02-28 06:22:05 +00:00
Changes:
- Added 'noclip' property to extra textures - Fixed multiple issues with texture scaling
This commit is contained in:
Lactozilla
parent
2325b1bd20
commit
e0885a4ad1
9 changed files with 333 additions and 146 deletions
|
|
@ -1198,12 +1198,12 @@ static void HWR_RenderMidtexture(INT32 gl_midtexture, float cliplow, float cliph
|
|||
// Left side
|
||||
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;
|
||||
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + gl_sidedef->textureoffset + gl_sidedef->offsetx_mid) * grTex->scaleX;
|
||||
|
||||
// Right side
|
||||
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;
|
||||
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + gl_sidedef->textureoffset + gl_sidedef->offsetx_mid) * grTex->scaleX;
|
||||
|
||||
// set top/bottom coords
|
||||
// Take the texture peg into account, rather than changing the offsets past
|
||||
|
|
@ -1429,12 +1429,24 @@ static void HWR_RenderExtraTexture(unsigned which, side_t *side, sector_t *sec_f
|
|||
fixed_t lowcutslope, highcutslope;
|
||||
|
||||
#define GET_CLIP_HEIGHTS() \
|
||||
if (polyobj) \
|
||||
if ((pfloor || polyobj) && (overlay->flags & SIDEOVERLAYFLAG_NOCLIP)) \
|
||||
{ \
|
||||
/* Overlay textures on poly objects aren't clipped */ \
|
||||
lowcut = lowcutslope = INT32_MIN; \
|
||||
highcut = highcutslope = INT32_MAX; \
|
||||
} \
|
||||
else if (polyobj) \
|
||||
{ \
|
||||
if (R_GetTextureNum(gl_sidedef->midtexture)) \
|
||||
{ \
|
||||
lowcut = lowcutslope = sec_back->floorheight; \
|
||||
highcut = highcutslope = sec_back->ceilingheight; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
lowcut = lowcutslope = INT32_MIN; \
|
||||
highcut = highcutslope = INT32_MAX; \
|
||||
} \
|
||||
} \
|
||||
else if (!sec_back) \
|
||||
{ \
|
||||
lowcut = worldbottom; \
|
||||
|
|
@ -1762,12 +1774,12 @@ static void HWR_RenderExtraTexture(unsigned which, side_t *side, sector_t *sec_f
|
|||
// Left side
|
||||
wallVerts[3].t = texturevpeg * yscale * grTex->scaleY;
|
||||
wallVerts[0].t = (h - l + texturevpeg) * yscale * grTex->scaleY;
|
||||
wallVerts[0].s = wallVerts[3].s = ((xcliplow * xscale) + overlay->offsetx) * grTex->scaleX;
|
||||
wallVerts[0].s = wallVerts[3].s = ((xcliplow * xscale) + gl_sidedef->textureoffset + overlay->offsetx) * grTex->scaleX;
|
||||
|
||||
// Right side
|
||||
wallVerts[2].t = texturevpegslope * yscale * grTex->scaleY;
|
||||
wallVerts[1].t = (hS - lS + texturevpegslope) * yscale * grTex->scaleY;
|
||||
wallVerts[2].s = wallVerts[1].s = ((xcliphigh * xscale) + overlay->offsetx) * grTex->scaleX;
|
||||
wallVerts[2].s = wallVerts[1].s = ((xcliphigh * xscale) + gl_sidedef->textureoffset + overlay->offsetx) * grTex->scaleX;
|
||||
|
||||
// set top/bottom coords
|
||||
wallVerts[3].y = FIXED_TO_FLOAT(h);
|
||||
|
|
@ -1869,12 +1881,12 @@ static void HWR_RenderExtraTexture(unsigned which, side_t *side, sector_t *sec_f
|
|||
// Left side
|
||||
wallVerts[3].t = texturevpeg * yscale * grTex->scaleY;
|
||||
wallVerts[0].t = (h - l + texturevpeg) * yscale * grTex->scaleY;
|
||||
wallVerts[0].s = wallVerts[3].s = ((xcliplow * xscale) + overlay->offsetx) * grTex->scaleX;
|
||||
wallVerts[0].s = wallVerts[3].s = ((xcliplow * xscale) + gl_sidedef->textureoffset + overlay->offsetx) * grTex->scaleX;
|
||||
|
||||
// Right side
|
||||
wallVerts[2].t = texturevpegslope * yscale * grTex->scaleY;
|
||||
wallVerts[1].t = (hS - lS + texturevpegslope) * yscale * grTex->scaleY;
|
||||
wallVerts[2].s = wallVerts[1].s = ((xcliphigh * xscale) + overlay->offsetx) * grTex->scaleX;
|
||||
wallVerts[2].s = wallVerts[1].s = ((xcliphigh * xscale) + gl_sidedef->textureoffset + overlay->offsetx) * grTex->scaleX;
|
||||
|
||||
RENDER_WALL_POLYGON();
|
||||
|
||||
|
|
@ -1883,7 +1895,7 @@ static void HWR_RenderExtraTexture(unsigned which, side_t *side, sector_t *sec_f
|
|||
|
||||
static void HWR_RenderFFloorExtraTextures(ffloor_t *pfloor, v2d_t vs, v2d_t ve, float xcliplow, float xcliphigh, FSurfaceInfo Surf, FBITFIELD blendmode)
|
||||
{
|
||||
side_t *pside = &sides[pfloor->master->sidenum[0]];
|
||||
side_t *pside = R_GetFFloorSide(gl_curline, pfloor);
|
||||
sector_t *psector = pfloor->master->frontsector;
|
||||
|
||||
HWR_RenderExtraTexture(EDGE_TEXTURE_TOP_UPPER, pside, psector, NULL, pfloor, NULL, vs, ve, xcliplow, xcliphigh, Surf, blendmode);
|
||||
|
|
@ -1961,9 +1973,8 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
wallVerts[2].z = wallVerts[1].z = ve.y;
|
||||
|
||||
// x offset the texture
|
||||
fixed_t texturehpeg = gl_sidedef->textureoffset + gl_curline->offset;
|
||||
float cliplow = (float)texturehpeg;
|
||||
float cliphigh = (float)(texturehpeg + (gl_curline->flength*FRACUNIT));
|
||||
float cliplow = (float)gl_curline->offset;
|
||||
float cliphigh = cliplow + (gl_curline->flength * FRACUNIT);
|
||||
|
||||
UINT32 lightnum = HWR_CalcWallLight(gl_frontsector->lightlevel, vs.x, vs.y, ve.x, ve.y);
|
||||
extracolormap_t *colormap = gl_frontsector->extra_colormap;
|
||||
|
|
@ -2013,7 +2024,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
xscale = FixedToFloat(abs(gl_sidedef->scalex_top));
|
||||
yscale = FixedToFloat(abs(gl_sidedef->scaley_top));
|
||||
|
||||
fixed_t offsetx_top = gl_sidedef->offsetx_top;
|
||||
fixed_t offsetx_top = gl_sidedef->textureoffset + gl_sidedef->offsetx_top;
|
||||
|
||||
float left = cliplow * xscale;
|
||||
float right = cliphigh * xscale;
|
||||
|
|
@ -2024,15 +2035,17 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
offsetx_top = -offsetx_top;
|
||||
}
|
||||
|
||||
fixed_t texheight = FixedDiv(textureheight[gl_toptexture], abs(gl_sidedef->scaley_top));
|
||||
fixed_t texheight = textureheight[gl_toptexture];
|
||||
fixed_t texheightscaled = FixedDiv(texheight, abs(gl_sidedef->scaley_top));
|
||||
|
||||
// PEGGING
|
||||
// FIXME: This is probably not correct?
|
||||
if (gl_linedef->flags & ML_DONTPEGTOP)
|
||||
texturevpeg = 0;
|
||||
else if (gl_linedef->flags & ML_SKEWTD)
|
||||
texturevpeg = worldhigh + texheight - worldtop;
|
||||
else
|
||||
texturevpeg = gl_backsector->ceilingheight + texheight - gl_frontsector->ceilingheight;
|
||||
texturevpeg = gl_backsector->ceilingheight + texheightscaled - gl_frontsector->ceilingheight;
|
||||
|
||||
texturevpeg *= yscale;
|
||||
|
||||
|
|
@ -2042,7 +2055,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
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 %= texheight;
|
||||
texturevpeg %= texheightscaled;
|
||||
|
||||
wallVerts[3].t = wallVerts[2].t = texturevpeg * grTex->scaleY;
|
||||
wallVerts[0].t = wallVerts[1].t = (texturevpeg + (gl_frontsector->ceilingheight - gl_backsector->ceilingheight) * yscale) * grTex->scaleY;
|
||||
|
|
@ -2103,7 +2116,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
xscale = FixedToFloat(abs(gl_sidedef->scalex_bottom));
|
||||
yscale = FixedToFloat(abs(gl_sidedef->scaley_bottom));
|
||||
|
||||
fixed_t offsetx_bottom = gl_sidedef->offsetx_bottom;
|
||||
fixed_t offsetx_bottom = gl_sidedef->textureoffset + gl_sidedef->offsetx_bottom;
|
||||
|
||||
float left = cliplow * xscale;
|
||||
float right = cliphigh * xscale;
|
||||
|
|
@ -2252,8 +2265,8 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
|
||||
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 * xscale) + gl_sidedef->offsetx_mid) * grTex->scaleX;
|
||||
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + gl_sidedef->offsetx_mid) * grTex->scaleX;
|
||||
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + gl_sidedef->textureoffset + gl_sidedef->offsetx_mid) * grTex->scaleX;
|
||||
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + gl_sidedef->textureoffset + gl_sidedef->offsetx_mid) * grTex->scaleX;
|
||||
|
||||
// Texture correction for slopes
|
||||
if (gl_linedef->flags & ML_NOSKEW) {
|
||||
|
|
@ -2320,8 +2333,9 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
// Used for height comparisons and etc across FOFs and slopes
|
||||
fixed_t high1, highslope1, low1, lowslope1;
|
||||
|
||||
fixed_t texturehpeg = gl_sidedef->textureoffset + gl_sidedef->offsetx_mid;
|
||||
|
||||
INT32 texnum;
|
||||
line_t * newline = NULL; // Multi-Property FOF
|
||||
|
||||
lowcut = max(worldbottom, worldlow);
|
||||
highcut = min(worldtop, worldhigh);
|
||||
|
|
@ -2355,16 +2369,14 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
if ((high1 < lowcut && highslope1 < lowcutslope) || (low1 > highcut && lowslope1 > highcutslope))
|
||||
continue;
|
||||
|
||||
side_t *side = &sides[rover->master->sidenum[0]];
|
||||
side_t *side = R_GetFFloorSide(gl_curline, rover);
|
||||
|
||||
boolean do_texture_skew;
|
||||
boolean dont_peg_bottom;
|
||||
|
||||
if (rover->master->flags & ML_TFERLINE)
|
||||
{
|
||||
size_t linenum = gl_curline->linedef-gl_backsector->lines[0];
|
||||
newline = rover->master->frontsector->lines[0] + linenum;
|
||||
side = &sides[newline->sidenum[0]];
|
||||
line_t *newline = R_GetFFloorLine(gl_curline, rover);
|
||||
do_texture_skew = newline->flags & ML_SKEWTD;
|
||||
dont_peg_bottom = newline->flags & ML_DONTPEGBOTTOM;
|
||||
}
|
||||
|
|
@ -2442,8 +2454,8 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
}
|
||||
}
|
||||
|
||||
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;
|
||||
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + texturehpeg + side->offsetx_mid) * grTex->scaleX;
|
||||
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + texturehpeg + side->offsetx_mid) * grTex->scaleX;
|
||||
}
|
||||
|
||||
FBITFIELD blendmode;
|
||||
|
|
@ -2514,13 +2526,21 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
if ((high1 < lowcut && highslope1 < lowcutslope) || (low1 > highcut && lowslope1 > highcutslope))
|
||||
continue;
|
||||
|
||||
side_t *side = &sides[rover->master->sidenum[0]];
|
||||
side_t *side = R_GetFFloorSide(gl_curline, rover);
|
||||
|
||||
boolean do_texture_skew;
|
||||
boolean dont_peg_bottom;
|
||||
|
||||
if (rover->master->flags & ML_TFERLINE)
|
||||
{
|
||||
size_t linenum = gl_curline->linedef-gl_backsector->lines[0];
|
||||
newline = rover->master->frontsector->lines[0] + linenum;
|
||||
side = &sides[newline->sidenum[0]];
|
||||
line_t *newline = R_GetFFloorLine(gl_curline, rover);
|
||||
do_texture_skew = newline->flags & ML_SKEWTD;
|
||||
dont_peg_bottom = newline->flags & ML_DONTPEGBOTTOM;
|
||||
}
|
||||
else
|
||||
{
|
||||
do_texture_skew = rover->master->flags & ML_SKEWTD;
|
||||
dont_peg_bottom = gl_curline->linedef->flags & ML_DONTPEGBOTTOM;
|
||||
}
|
||||
|
||||
texnum = R_GetTextureNum(side->midtexture);
|
||||
|
|
@ -2557,17 +2577,43 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
|
|||
}
|
||||
else
|
||||
{
|
||||
// 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
|
||||
fixed_t texturevpeg = side->rowoffset + side->offsety_mid;
|
||||
|
||||
grTex = HWR_GetTexture(texnum);
|
||||
xscale = FixedToFloat(side->scalex_mid);
|
||||
yscale = FixedToFloat(side->scaley_mid);
|
||||
|
||||
fixed_t diff = (*rover->topheight - h) * yscale;
|
||||
if (!do_texture_skew) // no skewing
|
||||
{
|
||||
if (dont_peg_bottom)
|
||||
texturevpeg -= (*rover->topheight - *rover->bottomheight) * yscale;
|
||||
|
||||
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[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 (!dont_peg_bottom) // skew by top
|
||||
{
|
||||
wallVerts[3].t = wallVerts[2].t = 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) * yscale) * grTex->scaleY;
|
||||
wallVerts[2].t = wallVerts[1].t - ((hS - lS) * yscale) * 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;
|
||||
wallVerts[0].s = wallVerts[3].s = ((cliplow * xscale) + texturehpeg + side->offsetx_mid) * grTex->scaleX;
|
||||
wallVerts[2].s = wallVerts[1].s = ((cliphigh * xscale) + texturehpeg + side->offsetx_mid) * grTex->scaleX;
|
||||
}
|
||||
|
||||
FBITFIELD blendmode;
|
||||
|
|
|
|||
|
|
@ -1462,6 +1462,7 @@ enum sideoverlay_e {
|
|||
sideoverlay_scalex,
|
||||
sideoverlay_scaley,
|
||||
sideoverlay_noskew,
|
||||
sideoverlay_noclip,
|
||||
sideoverlay_wrap
|
||||
};
|
||||
|
||||
|
|
@ -1473,6 +1474,7 @@ static const char *const sideoverlay_opt[] = {
|
|||
"scalex",
|
||||
"scaley",
|
||||
"noskew",
|
||||
"noclip",
|
||||
"wrap",
|
||||
NULL};
|
||||
|
||||
|
|
@ -1515,6 +1517,9 @@ static int sideoverlay_get(lua_State *L)
|
|||
case sideoverlay_noskew:
|
||||
lua_pushboolean(L, overlay->flags & SIDEOVERLAYFLAG_NOSKEW);
|
||||
return 1;
|
||||
case sideoverlay_noclip:
|
||||
lua_pushboolean(L, overlay->flags & SIDEOVERLAYFLAG_NOCLIP);
|
||||
return 1;
|
||||
case sideoverlay_wrap:
|
||||
lua_pushboolean(L, overlay->flags & SIDEOVERLAYFLAG_WRAP);
|
||||
return 1;
|
||||
|
|
@ -1544,6 +1549,8 @@ static int sideoverlay_set(lua_State *L)
|
|||
return luaL_error(L, "side_t.overlay has no field named " LUA_QS ".", lua_tostring(L, 2));
|
||||
case sideoverlay_texture:
|
||||
overlay->texture = luaL_checkinteger(L, 3);
|
||||
if (overlay->texture)
|
||||
overlay->side->flags |= SIDEFLAG_HASEDGETEXTURES;
|
||||
break;
|
||||
case sideoverlay_offsetx:
|
||||
overlay->offsetx = luaL_checkfixed(L, 3);
|
||||
|
|
@ -1563,6 +1570,12 @@ static int sideoverlay_set(lua_State *L)
|
|||
else
|
||||
overlay->flags &= ~SIDEOVERLAYFLAG_NOSKEW;
|
||||
break;
|
||||
case sideoverlay_noclip:
|
||||
if (luaL_checkboolean(L, 3))
|
||||
overlay->flags |= SIDEOVERLAYFLAG_NOCLIP;
|
||||
else
|
||||
overlay->flags &= ~SIDEOVERLAYFLAG_NOCLIP;
|
||||
break;
|
||||
case sideoverlay_wrap:
|
||||
if (luaL_checkboolean(L, 3))
|
||||
overlay->flags |= SIDEOVERLAYFLAG_WRAP;
|
||||
|
|
|
|||
|
|
@ -1428,6 +1428,8 @@ static UINT32 GetSideDiff(const side_t *si, const side_t *spawnsi, UINT8 edgedif
|
|||
diff |= LD_SDBOTSCALEY;
|
||||
if (si->repeatcnt != spawnsi->repeatcnt)
|
||||
diff |= LD_SDREPEATCNT;
|
||||
if (si->flags != spawnsi->flags)
|
||||
diff |= LD_SDFLAGS;
|
||||
if (edgediff[0] != 0)
|
||||
diff |= LD_SDOVERLAY1;
|
||||
if (edgediff[1] != 0)
|
||||
|
|
@ -1497,6 +1499,8 @@ static void ArchiveSide(const side_t *si, UINT32 diff, UINT8 edgediff[4])
|
|||
WRITEFIXED(save_p, si->scaley_bottom);
|
||||
if (diff & LD_SDREPEATCNT)
|
||||
WRITEINT16(save_p, si->repeatcnt);
|
||||
if (diff & LD_SDFLAGS)
|
||||
WRITEUINT16(save_p, si->flags);
|
||||
if (diff & LD_SDOVERLAY1)
|
||||
ArchiveSideEdge(&si->overlays[0], edgediff[0]);
|
||||
if (diff & LD_SDOVERLAY2)
|
||||
|
|
@ -1672,6 +1676,8 @@ static void UnArchiveSide(side_t *si)
|
|||
si->scaley_bottom = READFIXED(save_p);
|
||||
if (diff & LD_SDREPEATCNT)
|
||||
si->repeatcnt = READINT16(save_p);
|
||||
if (diff & LD_SDFLAGS)
|
||||
si->flags = READUINT16(save_p);
|
||||
if (diff & LD_SDOVERLAY1)
|
||||
UnArchiveSideEdge(&si->overlays[0]);
|
||||
if (diff & LD_SDOVERLAY2)
|
||||
|
|
|
|||
|
|
@ -1331,6 +1331,18 @@ static void P_WriteTics(INT32 tics, char **target)
|
|||
P_WriteDuplicateText(text, target);
|
||||
}
|
||||
|
||||
static void P_InitSideEdges(side_t *sd)
|
||||
{
|
||||
for (unsigned j = 0; j < NUM_WALL_OVERLAYS; j++)
|
||||
{
|
||||
sd->overlays[j].texture = R_TextureNumForName("-");
|
||||
sd->overlays[j].offsetx = sd->overlays[j].offsety = 0;
|
||||
sd->overlays[j].scalex = sd->overlays[j].scaley = FRACUNIT;
|
||||
sd->overlays[j].flags = 0;
|
||||
sd->overlays[j].side = sd;
|
||||
}
|
||||
}
|
||||
|
||||
static void P_LoadSidedefs(UINT8 *data)
|
||||
{
|
||||
mapsidedef_t *msd = (mapsidedef_t*)data;
|
||||
|
|
@ -1366,13 +1378,7 @@ static void P_LoadSidedefs(UINT8 *data)
|
|||
sd->scalex_top = sd->scalex_mid = sd->scalex_bottom = FRACUNIT;
|
||||
sd->scaley_top = sd->scaley_mid = sd->scaley_bottom = FRACUNIT;
|
||||
|
||||
for (unsigned j = 0; j < NUM_WALL_OVERLAYS; j++)
|
||||
{
|
||||
sd->overlays[j].texture = R_TextureNumForName("-");
|
||||
sd->overlays[j].offsetx = sd->overlays[j].offsety = 0;
|
||||
sd->overlays[j].scalex = sd->overlays[j].scaley = FRACUNIT;
|
||||
sd->overlays[j].flags = 0;
|
||||
}
|
||||
P_InitSideEdges(sd);
|
||||
|
||||
P_SetSidedefSector(i, (UINT16)SHORT(msd->sector));
|
||||
|
||||
|
|
@ -1908,7 +1914,11 @@ static void ParseTextmapSidedefOverlay(unsigned which, UINT32 i, const char *par
|
|||
{
|
||||
side_overlay_t *overlay = &sides[i].overlays[which];
|
||||
if (fastcmp(param, "texture"))
|
||||
{
|
||||
overlay->texture = R_TextureNumForName(val);
|
||||
if (overlay->texture)
|
||||
sides[i].flags |= SIDEFLAG_HASEDGETEXTURES;
|
||||
}
|
||||
else if (fastcmp(param, "offsetx"))
|
||||
overlay->offsetx = FLOAT_TO_FIXED(atof(val));
|
||||
else if (fastcmp(param, "offsety"))
|
||||
|
|
@ -1919,6 +1929,8 @@ static void ParseTextmapSidedefOverlay(unsigned which, UINT32 i, const char *par
|
|||
overlay->scaley = FLOAT_TO_FIXED(atof(val));
|
||||
else if (fastcmp(param, "noskew") && fastcmp("true", val))
|
||||
overlay->flags |= SIDEOVERLAYFLAG_NOSKEW;
|
||||
else if (fastcmp(param, "noclip") && fastcmp("true", val))
|
||||
overlay->flags |= SIDEOVERLAYFLAG_NOCLIP;
|
||||
else if (fastcmp(param, "wrap") && fastcmp("true", val))
|
||||
overlay->flags |= SIDEOVERLAYFLAG_WRAP;
|
||||
}
|
||||
|
|
@ -2243,6 +2255,8 @@ static void WriteTextmapEdgeTexture(const char *prefix, unsigned i, side_t *side
|
|||
fprintf(f, "%s""scaley = %f;\n", prefix, FIXED_TO_FLOAT(side->overlays[i].scaley));
|
||||
if (side->overlays[i].flags & SIDEOVERLAYFLAG_NOSKEW)
|
||||
fprintf(f, "%s""noskew = true;\n", prefix);
|
||||
if (side->overlays[i].flags & SIDEOVERLAYFLAG_NOCLIP)
|
||||
fprintf(f, "%s""noclip = true;\n", prefix);
|
||||
if (side->overlays[i].flags & SIDEOVERLAYFLAG_WRAP)
|
||||
fprintf(f, "%s""wrap = true;\n", prefix);
|
||||
}
|
||||
|
|
@ -3105,16 +3119,11 @@ static void P_LoadTextmap(void)
|
|||
sd->toptexture = R_TextureNumForName("-");
|
||||
sd->midtexture = R_TextureNumForName("-");
|
||||
sd->bottomtexture = R_TextureNumForName("-");
|
||||
for (unsigned j = 0; j < NUM_WALL_OVERLAYS; j++)
|
||||
{
|
||||
sd->overlays[j].texture = R_TextureNumForName("-");
|
||||
sd->overlays[j].offsetx = sd->overlays[j].offsety = 0;
|
||||
sd->overlays[j].scalex = sd->overlays[j].scaley = FRACUNIT;
|
||||
sd->overlays[j].flags = 0;
|
||||
}
|
||||
sd->sector = NULL;
|
||||
sd->repeatcnt = 0;
|
||||
|
||||
P_InitSideEdges(sd);
|
||||
|
||||
TextmapParse(sidesPos[i], i, ParseTextmapSidedefParameter);
|
||||
|
||||
if (!sd->sector)
|
||||
|
|
@ -3407,8 +3416,6 @@ static void P_InitializeSeg(seg_t *seg)
|
|||
seg->lightmaps = NULL; // list of static lightmap for this seg
|
||||
#endif
|
||||
|
||||
seg->numlights = 0;
|
||||
seg->rlights = NULL;
|
||||
seg->polyseg = NULL;
|
||||
seg->dontrenderme = false;
|
||||
}
|
||||
|
|
|
|||
19
src/r_defs.h
19
src/r_defs.h
|
|
@ -610,10 +610,16 @@ typedef struct line_s
|
|||
} line_t;
|
||||
|
||||
// Don't make available to Lua or I will find where you live
|
||||
typedef enum
|
||||
{
|
||||
SIDEFLAG_HASEDGETEXTURES = 1
|
||||
} sideflags_t;
|
||||
|
||||
enum
|
||||
{
|
||||
SIDEOVERLAYFLAG_NOSKEW = 1<<0,
|
||||
SIDEOVERLAYFLAG_WRAP = 1<<1
|
||||
SIDEOVERLAYFLAG_NOCLIP = 1<<1,
|
||||
SIDEOVERLAYFLAG_WRAP = 1<<2
|
||||
};
|
||||
|
||||
typedef struct
|
||||
|
|
@ -622,9 +628,10 @@ typedef struct
|
|||
fixed_t offsetx, offsety;
|
||||
fixed_t scalex, scaley;
|
||||
UINT8 flags;
|
||||
struct side_s *side;
|
||||
} side_overlay_t;
|
||||
|
||||
typedef struct
|
||||
typedef struct side_s
|
||||
{
|
||||
// add this to the calculated texture column
|
||||
fixed_t textureoffset;
|
||||
|
|
@ -632,13 +639,16 @@ typedef struct
|
|||
// add this to the calculated texture top
|
||||
fixed_t rowoffset;
|
||||
|
||||
// per-texture offsets for UDMF
|
||||
// per-texture offsets
|
||||
fixed_t offsetx_top, offsetx_mid, offsetx_bottom;
|
||||
fixed_t offsety_top, offsety_mid, offsety_bottom;
|
||||
|
||||
// per-texture scale
|
||||
fixed_t scalex_top, scalex_mid, scalex_bottom;
|
||||
fixed_t scaley_top, scaley_mid, scaley_bottom;
|
||||
|
||||
UINT16 flags;
|
||||
|
||||
// Texture indices.
|
||||
// We do not maintain names here.
|
||||
INT32 toptexture, bottomtexture, midtexture;
|
||||
|
|
@ -766,9 +776,6 @@ typedef struct seg_s
|
|||
lightmap_t *lightmaps; // for static lightmap
|
||||
#endif
|
||||
|
||||
// Why slow things down by calculating lightlists for every thick side?
|
||||
size_t numlights;
|
||||
r_lightlist_t *rlights;
|
||||
polyobj_t *polyseg;
|
||||
boolean dontrenderme;
|
||||
boolean glseg;
|
||||
|
|
|
|||
41
src/r_main.c
41
src/r_main.c
|
|
@ -407,33 +407,26 @@ angle_t R_PointToAngleEx(INT32 x2, INT32 y2, INT32 x1, INT32 y1)
|
|||
0;
|
||||
}
|
||||
|
||||
//
|
||||
// R_ScaleFromGlobalAngle
|
||||
// Returns the texture mapping scale for the current line (horizontal span)
|
||||
// at the given angle.
|
||||
// rw_distance must be calculated first.
|
||||
//
|
||||
// killough 5/2/98: reformatted, cleaned up
|
||||
//
|
||||
// note: THIS IS USED ONLY FOR WALLS!
|
||||
fixed_t R_ScaleFromGlobalAngle(angle_t visangle)
|
||||
line_t *R_GetFFloorLine(const seg_t *seg, const ffloor_t *pfloor)
|
||||
{
|
||||
angle_t anglea = ANGLE_90 + (visangle-viewangle);
|
||||
angle_t angleb = ANGLE_90 + (visangle-rw_normalangle);
|
||||
fixed_t den = FixedMul(rw_distance, FINESINE(anglea>>ANGLETOFINESHIFT));
|
||||
// proff 11/06/98: Changed for high-res
|
||||
fixed_t num = FixedMul(projectiony, FINESINE(angleb>>ANGLETOFINESHIFT));
|
||||
|
||||
if (den > num>>16)
|
||||
if (pfloor->master->flags & ML_TFERLINE)
|
||||
{
|
||||
num = FixedDiv(num, den);
|
||||
if (num > 64*FRACUNIT)
|
||||
return 64*FRACUNIT;
|
||||
if (num < 256)
|
||||
return 256;
|
||||
return num;
|
||||
size_t linenum = seg->linedef - pfloor->target->lines[0];
|
||||
return pfloor->master->frontsector->lines[0] + linenum;
|
||||
}
|
||||
return 64*FRACUNIT;
|
||||
else
|
||||
return pfloor->master;
|
||||
}
|
||||
|
||||
side_t *R_GetFFloorSide(const seg_t *seg, const ffloor_t *pfloor)
|
||||
{
|
||||
if (pfloor->master->flags & ML_TFERLINE)
|
||||
{
|
||||
line_t *newline = R_GetFFloorLine(seg, pfloor);
|
||||
return &sides[newline->sidenum[0]];
|
||||
}
|
||||
else
|
||||
return &sides[pfloor->master->sidenum[0]];
|
||||
}
|
||||
|
||||
//
|
||||
|
|
|
|||
|
|
@ -81,13 +81,15 @@ angle_t R_PointToAngleEx(INT32 x2, INT32 y2, INT32 x1, INT32 y1);
|
|||
fixed_t R_PointToDist(fixed_t x, fixed_t y);
|
||||
fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1);
|
||||
|
||||
fixed_t R_ScaleFromGlobalAngle(angle_t visangle);
|
||||
boolean R_IsPointInSector(sector_t *sector, fixed_t x, fixed_t y);
|
||||
subsector_t *R_PointInSubsector(fixed_t x, fixed_t y);
|
||||
subsector_t *R_PointInSubsectorOrNull(fixed_t x, fixed_t y);
|
||||
|
||||
boolean R_DoCulling(line_t *cullheight, line_t *viewcullheight, fixed_t vz, fixed_t bottomh, fixed_t toph);
|
||||
|
||||
line_t *R_GetFFloorLine(const seg_t *seg, const ffloor_t *pfloor);
|
||||
side_t *R_GetFFloorSide(const seg_t *seg, const ffloor_t *pfloor);
|
||||
|
||||
// Render stats
|
||||
|
||||
extern precise_t ps_prevframetime;// time when previous frame was rendered
|
||||
|
|
|
|||
173
src/r_segs.c
173
src/r_segs.c
|
|
@ -64,7 +64,7 @@ static struct
|
|||
fixed_t mid, slide;
|
||||
fixed_t back, backslide;
|
||||
fixed_t scalex, scaley;
|
||||
fixed_t invscalex, invscaley;
|
||||
fixed_t invscalex;
|
||||
fixed_t offsetx, offsety;
|
||||
} rw_overlay[NUM_WALL_OVERLAYS];
|
||||
|
||||
|
|
@ -617,9 +617,6 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
|
|||
else
|
||||
dc_texturemid -= (textureheight[texnum])*times;
|
||||
|
||||
if (hasoverlaytexture && times == 0)
|
||||
R_DoMaskedOverlayColumn(dc_x, maskedtexturecol[dc_x], INT32_MAX, INT32_MAX);
|
||||
|
||||
// Check for overflows first
|
||||
overflow_test = (INT64)centeryfrac - (((INT64)dc_texturemid*spryscale)>>FRACBITS);
|
||||
if (overflow_test < 0) overflow_test = -overflow_test;
|
||||
|
|
@ -653,6 +650,9 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
|
|||
|
||||
sprtopscreen = centeryfrac - FixedMul(texture_top, spryscale);
|
||||
|
||||
if (hasoverlaytexture && times == 0)
|
||||
R_DoMaskedOverlayColumn(dc_x, maskedtexturecol[dc_x], sprtopscreen, centeryfrac - FixedMul(texture_bottom, spryscale));
|
||||
|
||||
// set wall bounds if there is a light list, or if this is a polyobject side
|
||||
if (dc_numlights || curline->polyseg)
|
||||
{
|
||||
|
|
@ -845,9 +845,6 @@ static void R_RenderExtraTexture(unsigned which, INT32 x1, INT32 x2, INT32 repea
|
|||
// Setup lighting based on the presence/lack-of 3D floors.
|
||||
R_PrepareMaskedSegLightlist(ds, range);
|
||||
|
||||
mfloorclip = overlayopening[1];
|
||||
mceilingclip = overlayopening[0];
|
||||
|
||||
for (times = 0; times < repeats; times++)
|
||||
{
|
||||
if (times > 0)
|
||||
|
|
@ -1025,6 +1022,11 @@ static boolean R_IsFFloorTranslucent(visffloor_t *pfloor)
|
|||
return false;
|
||||
}
|
||||
|
||||
static fixed_t R_GetSlopeTextureSlide(pslope_t *slope, angle_t lineangle)
|
||||
{
|
||||
return FixedMul(slope->zdelta, FINECOSINE((lineangle-slope->xydirection)>>ANGLETOFINESHIFT));
|
||||
}
|
||||
|
||||
//
|
||||
// R_RenderThickSideRange
|
||||
// Renders all the thick sides in the given range.
|
||||
|
|
@ -1050,11 +1052,12 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
// skew FOF walls with slopes?
|
||||
fixed_t ffloortextureslide = 0, topslopeslide = 0, bottomslopeslide = 0;
|
||||
angle_t lineangle;
|
||||
INT32 oldx = -1;
|
||||
fixed_t oldtexturecolumn = -1;
|
||||
fixed_t left_top, left_bottom; // needed here for slope skewing
|
||||
pslope_t *skewslope = NULL;
|
||||
boolean do_texture_skew;
|
||||
boolean dont_peg_bottom;
|
||||
fixed_t wall_offsetx;
|
||||
fixed_t wall_scalex, wall_scaley;
|
||||
INT32 blendlevel = 0;
|
||||
UINT8 vertflip;
|
||||
|
|
@ -1069,15 +1072,13 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
curline = ds->curline;
|
||||
backsector = NULL;
|
||||
frontsector = curline->frontsector == pfloor->target ? curline->backsector : curline->frontsector;
|
||||
sidedef = &sides[pfloor->master->sidenum[0]];
|
||||
sidedef = R_GetFFloorSide(curline, pfloor);
|
||||
|
||||
colfunc = colfuncs[BASEDRAWFUNC];
|
||||
|
||||
if (pfloor->master->flags & ML_TFERLINE)
|
||||
{
|
||||
size_t linenum = curline->linedef-pfloor->target->lines[0];
|
||||
line_t *newline = pfloor->master->frontsector->lines[0] + linenum;
|
||||
sidedef = &sides[newline->sidenum[0]];
|
||||
line_t *newline = R_GetFFloorLine(curline, pfloor);
|
||||
do_texture_skew = newline->flags & ML_SKEWTD;
|
||||
dont_peg_bottom = newline->flags & ML_DONTPEGBOTTOM;
|
||||
}
|
||||
|
|
@ -1248,15 +1249,17 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
|
||||
thicksidecol = ffloortexturecolumn;
|
||||
|
||||
wall_offsetx = ds->offsetx + sidedef->offsetx_mid;
|
||||
|
||||
if (wall_scalex == FRACUNIT)
|
||||
{
|
||||
for (INT32 x = x1; x <= x2; x++)
|
||||
thicksidecol[x] = ds->thicksidecol[x] + ds->offsetx;
|
||||
thicksidecol[x] = ds->thicksidecol[x];
|
||||
}
|
||||
else
|
||||
{
|
||||
for (INT32 x = x1; x <= x2; x++)
|
||||
thicksidecol[x] = FixedDiv(ds->thicksidecol[x], wall_scalex) + ds->offsetx;
|
||||
thicksidecol[x] = FixedDiv(ds->thicksidecol[x], wall_scalex);
|
||||
}
|
||||
|
||||
mfloorclip = ds->sprbottomclip;
|
||||
|
|
@ -1291,7 +1294,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
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(R_GetSlopeTextureSlide(skewslope, lineangle), wall_scaley);
|
||||
|
||||
dc_texturemid += offsetvalue;
|
||||
|
||||
|
|
@ -1348,9 +1351,9 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
if (hasoverlaytexture)
|
||||
{
|
||||
if (*pfloor->t_slope)
|
||||
topslopeslide = FixedMul((*pfloor->t_slope)->zdelta, FINECOSINE((lineangle-(*pfloor->t_slope)->xydirection)>>ANGLETOFINESHIFT));
|
||||
topslopeslide = R_GetSlopeTextureSlide(*pfloor->t_slope, lineangle);
|
||||
if (*pfloor->b_slope)
|
||||
bottomslopeslide = FixedMul((*pfloor->b_slope)->zdelta, FINECOSINE((lineangle-(*pfloor->b_slope)->xydirection)>>ANGLETOFINESHIFT));
|
||||
bottomslopeslide = R_GetSlopeTextureSlide(*pfloor->b_slope, lineangle);
|
||||
|
||||
R_AddOverlayTextures(pfloor->master->frontsector, NULL, left_top, left_bottom, 0, 0, topslopeslide, bottomslopeslide, 0, 0);
|
||||
|
||||
|
|
@ -1364,9 +1367,9 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
// skew FOF walls
|
||||
if (ffloortextureslide)
|
||||
{
|
||||
if (oldx != -1)
|
||||
dc_texturemid += FixedMul(ffloortextureslide, thicksidecol[oldx]-thicksidecol[dc_x]);
|
||||
oldx = dc_x;
|
||||
if (oldtexturecolumn != -1)
|
||||
dc_texturemid += FixedMul(ffloortextureslide, oldtexturecolumn-ds->thicksidecol[dc_x]);
|
||||
oldtexturecolumn = ds->thicksidecol[dc_x];
|
||||
}
|
||||
|
||||
// Calculate bounds
|
||||
|
|
@ -1404,7 +1407,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
dc_iscale = FixedMul(0xffffffffu / (unsigned)spryscale, wall_scaley);
|
||||
|
||||
// Get data for the column
|
||||
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (thicksidecol[dc_x] >> FRACBITS)) - 3);
|
||||
col = (column_t *)((UINT8 *)R_GetColumn(texnum, ((thicksidecol[dc_x] + wall_offsetx) >> FRACBITS)) - 3);
|
||||
|
||||
// SoM: New code does not rely on R_DrawColumnShadowed_8 which
|
||||
// will (hopefully) put less strain on the stack.
|
||||
|
|
@ -1939,8 +1942,8 @@ static void R_RenderSegLoop (void)
|
|||
ceilingclip[rw_x] = topclip;
|
||||
|
||||
if (oldtexturecolumn_top != -1)
|
||||
rw_toptexturemid += FixedMul(rw_toptextureslide, oldtexturecolumn_top-toptexturecolumn);
|
||||
oldtexturecolumn_top = toptexturecolumn;
|
||||
rw_toptexturemid += FixedMul(rw_toptextureslide, oldtexturecolumn_top-textureoffset);
|
||||
oldtexturecolumn_top = textureoffset;
|
||||
}
|
||||
else if (markceiling && (!rw_ceilingmarked)) // no top wall
|
||||
ceilingclip[rw_x] = topclip;
|
||||
|
|
@ -1985,8 +1988,8 @@ static void R_RenderSegLoop (void)
|
|||
floorclip[rw_x] = bottomclip;
|
||||
|
||||
if (oldtexturecolumn_bottom != -1)
|
||||
rw_bottomtexturemid += FixedMul(rw_bottomtextureslide, oldtexturecolumn_bottom-bottomtexturecolumn);
|
||||
oldtexturecolumn_bottom = bottomtexturecolumn;
|
||||
rw_bottomtexturemid += FixedMul(rw_bottomtextureslide, oldtexturecolumn_bottom-textureoffset);
|
||||
oldtexturecolumn_bottom = textureoffset;
|
||||
}
|
||||
else if (markfloor && (!rw_floormarked)) // no bottom wall
|
||||
floorclip[rw_x] = bottomclip;
|
||||
|
|
@ -2010,14 +2013,14 @@ static void R_RenderSegLoop (void)
|
|||
{
|
||||
if (oldtexturecolumn != -1)
|
||||
{
|
||||
INT32 diff = oldtexturecolumn-texturecolumn;
|
||||
INT32 diff = oldtexturecolumn-textureoffset;
|
||||
if (rw_invmidtexturescalex < 0)
|
||||
diff = -diff;
|
||||
rw_midtexturemid += FixedMul(rw_midtextureslide, diff);
|
||||
rw_midtextureback += FixedMul(rw_midtexturebackslide, diff);
|
||||
}
|
||||
|
||||
oldtexturecolumn = texturecolumn;
|
||||
oldtexturecolumn = textureoffset;
|
||||
}
|
||||
|
||||
if (hasoverlaytexture)
|
||||
|
|
@ -2167,6 +2170,9 @@ static void R_AllocTextureColumnTables(size_t range)
|
|||
|
||||
static boolean R_CheckExtraTextures(boolean onesided)
|
||||
{
|
||||
if (!(sidedef->flags & SIDEFLAG_HASEDGETEXTURES))
|
||||
return false;
|
||||
|
||||
INT32 texnums[4] = {
|
||||
R_GetTextureNum(sidedef->overlays[0].texture),
|
||||
R_GetTextureNum(sidedef->overlays[1].texture),
|
||||
|
|
@ -2214,7 +2220,6 @@ static void R_AddOverlayTextures(sector_t *sec_front, sector_t *sec_back, fixed_
|
|||
rw_overlay[i].offsety = sidedef->overlays[i].offsety;
|
||||
|
||||
rw_overlay[i].invscalex = FixedDiv(FRACUNIT, rw_overlay[i].scalex);
|
||||
rw_overlay[i].invscaley = FixedDiv(FRACUNIT, abs(rw_overlay[i].scaley));
|
||||
|
||||
if (sidedef->overlays[i].flags & SIDEOVERLAYFLAG_NOSKEW)
|
||||
{
|
||||
|
|
@ -2267,6 +2272,9 @@ static void R_AddOverlayTextures(sector_t *sec_front, sector_t *sec_back, fixed_
|
|||
rw_overlay[i].mid = FixedMul(rw_overlay[i].mid, abs(rw_overlay[i].scaley));
|
||||
rw_overlay[i].back = FixedMul(rw_overlay[i].back, abs(rw_overlay[i].scaley));
|
||||
|
||||
rw_overlay[i].slide = FixedMul(rw_overlay[i].slide, abs(rw_overlay[i].scaley));
|
||||
rw_overlay[i].backslide = FixedMul(rw_overlay[i].backslide, abs(rw_overlay[i].scaley));
|
||||
|
||||
rw_overlay[i].mid += sidedef->rowoffset + rw_overlay[i].offsety;
|
||||
rw_overlay[i].back += sidedef->rowoffset + rw_overlay[i].offsety;
|
||||
}
|
||||
|
|
@ -2304,13 +2312,13 @@ static void R_StoreOverlayColumn(INT32 x, fixed_t textureoffset)
|
|||
if (rw_overlay[i].scalex < 0)
|
||||
offset = -offset;
|
||||
|
||||
overlaycolumn[i] = FixedDiv(textureoffset, rw_overlay[i].invscaley);
|
||||
overlaycolumn[i] = textureoffset;
|
||||
overlaytexturecol[i][x] = FixedDiv(textureoffset, rw_overlay[i].invscalex) + offset;
|
||||
|
||||
if (oldoverlaycolumn[i] != -1)
|
||||
{
|
||||
INT32 diff = oldoverlaycolumn[i]-overlaycolumn[i];
|
||||
if (rw_overlay[i].scalex < 0)
|
||||
if (rw_overlay[i].invscalex < 0)
|
||||
diff = -diff;
|
||||
rw_overlay[i].mid += FixedMul(rw_overlay[i].slide, diff);
|
||||
rw_overlay[i].back += FixedMul(rw_overlay[i].backslide, diff);
|
||||
|
|
@ -2320,25 +2328,62 @@ static void R_StoreOverlayColumn(INT32 x, fixed_t textureoffset)
|
|||
}
|
||||
}
|
||||
|
||||
static void R_RenderSingleOverlayTexture(unsigned which, drawseg_t *ds, INT32 x1, INT32 x2, sector_t *sec_front, sector_t *sec_back, UINT32 blendmode, UINT8 blendlevel)
|
||||
{
|
||||
if (!overlaytexture[which])
|
||||
return;
|
||||
|
||||
INT32 repeats = R_GetOverlayTextureRepeats(which, sidedef, overlaytexture[which],
|
||||
sec_front, sec_back,
|
||||
ds->leftpos.x, ds->leftpos.y, ds->rightpos.x, ds->rightpos.y);
|
||||
|
||||
if (sidedef->overlays[which].flags & SIDEOVERLAYFLAG_NOCLIP)
|
||||
{
|
||||
mfloorclip = ds->sprbottomclip;
|
||||
mceilingclip = ds->sprtopclip;
|
||||
}
|
||||
else
|
||||
{
|
||||
mfloorclip = overlayopening[1];
|
||||
mceilingclip = overlayopening[0];
|
||||
}
|
||||
|
||||
R_RenderExtraTexture(which, x1, x2, repeats, blendmode, blendlevel, ds);
|
||||
}
|
||||
|
||||
static void R_RenderMaskedOverlayTextures(drawseg_t *ds, INT32 x1, INT32 x2, sector_t *sec_front, sector_t *sec_back, UINT32 blendmode, UINT8 blendlevel)
|
||||
{
|
||||
INT32 repeats;
|
||||
R_RenderSingleOverlayTexture(EDGE_TEXTURE_TOP_UPPER, ds, x1, x2, sec_front, sec_back, blendmode, blendlevel);
|
||||
R_RenderSingleOverlayTexture(EDGE_TEXTURE_BOTTOM_LOWER, ds, x1, x2, sec_front, sec_back, blendmode, blendlevel);
|
||||
}
|
||||
|
||||
if (overlaytexture[EDGE_TEXTURE_TOP_UPPER])
|
||||
{
|
||||
repeats = R_GetOverlayTextureRepeats(EDGE_TEXTURE_TOP_UPPER, sidedef, overlaytexture[EDGE_TEXTURE_TOP_UPPER],
|
||||
sec_front, sec_back,
|
||||
ds->leftpos.x, ds->leftpos.y, ds->rightpos.x, ds->rightpos.y);
|
||||
R_RenderExtraTexture(EDGE_TEXTURE_TOP_UPPER, x1, x2, repeats, blendmode, blendlevel, ds);
|
||||
}
|
||||
//
|
||||
// R_ScaleFromGlobalAngle
|
||||
// Returns the texture mapping scale for the current line (horizontal span)
|
||||
// at the given angle.
|
||||
// rw_distance must be calculated first.
|
||||
//
|
||||
// killough 5/2/98: reformatted, cleaned up
|
||||
//
|
||||
// note: THIS IS USED ONLY FOR WALLS!
|
||||
static fixed_t R_ScaleFromGlobalAngle(angle_t visangle)
|
||||
{
|
||||
angle_t anglea = ANGLE_90 + (visangle-viewangle);
|
||||
angle_t angleb = ANGLE_90 + (visangle-rw_normalangle);
|
||||
fixed_t den = FixedMul(rw_distance, FINESINE(anglea>>ANGLETOFINESHIFT));
|
||||
// proff 11/06/98: Changed for high-res
|
||||
fixed_t num = FixedMul(projectiony, FINESINE(angleb>>ANGLETOFINESHIFT));
|
||||
|
||||
if (overlaytexture[EDGE_TEXTURE_BOTTOM_LOWER])
|
||||
if (den > num>>16)
|
||||
{
|
||||
repeats = R_GetOverlayTextureRepeats(EDGE_TEXTURE_BOTTOM_LOWER, sidedef, overlaytexture[EDGE_TEXTURE_BOTTOM_LOWER],
|
||||
sec_front, sec_back,
|
||||
ds->leftpos.x, ds->leftpos.y, ds->rightpos.x, ds->rightpos.y);
|
||||
R_RenderExtraTexture(EDGE_TEXTURE_BOTTOM_LOWER, x1, x2, repeats, blendmode, blendlevel, ds);
|
||||
num = FixedDiv(num, den);
|
||||
if (num > 64*FRACUNIT)
|
||||
return 64*FRACUNIT;
|
||||
if (num < 256)
|
||||
return 256;
|
||||
return num;
|
||||
}
|
||||
return 64*FRACUNIT;
|
||||
}
|
||||
|
||||
//
|
||||
|
|
@ -2555,16 +2600,19 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
|||
angle_t lineangle = R_PointToAngle2(curline->v1->x, curline->v1->y, curline->v2->x, curline->v2->y);
|
||||
|
||||
if (frontsector->f_slope)
|
||||
floorfrontslide = FixedMul(frontsector->f_slope->zdelta, FINECOSINE((lineangle-frontsector->f_slope->xydirection)>>ANGLETOFINESHIFT));
|
||||
floorfrontslide = R_GetSlopeTextureSlide(frontsector->f_slope, lineangle);
|
||||
|
||||
if (frontsector->c_slope)
|
||||
ceilingfrontslide = FixedMul(frontsector->c_slope->zdelta, FINECOSINE((lineangle-frontsector->c_slope->xydirection)>>ANGLETOFINESHIFT));
|
||||
ceilingfrontslide = R_GetSlopeTextureSlide(frontsector->c_slope, lineangle);
|
||||
|
||||
if (backsector && backsector->f_slope)
|
||||
floorbackslide = FixedMul(backsector->f_slope->zdelta, FINECOSINE((lineangle-backsector->f_slope->xydirection)>>ANGLETOFINESHIFT));
|
||||
if (backsector)
|
||||
{
|
||||
if (backsector->f_slope)
|
||||
floorbackslide = R_GetSlopeTextureSlide(backsector->f_slope, lineangle);
|
||||
|
||||
if (backsector && backsector->c_slope)
|
||||
ceilingbackslide = FixedMul(backsector->c_slope->zdelta, FINECOSINE((lineangle-backsector->c_slope->xydirection)>>ANGLETOFINESHIFT));
|
||||
if (backsector->c_slope)
|
||||
ceilingbackslide = R_GetSlopeTextureSlide(backsector->c_slope, lineangle);
|
||||
}
|
||||
}
|
||||
|
||||
rw_midtexturescalex = sidedef->scalex_mid;
|
||||
|
|
@ -2594,13 +2642,13 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
|||
else if (linedef->flags & ML_DONTPEGBOTTOM)
|
||||
{
|
||||
rw_midtexturemid = FixedMul(worldbottom, scaley) + texheight;
|
||||
rw_midtextureslide = floorfrontslide;
|
||||
rw_midtextureslide = FixedMul(floorfrontslide, scaley);
|
||||
}
|
||||
else
|
||||
{
|
||||
// top of texture at top
|
||||
rw_midtexturemid = FixedMul(worldtop, scaley);
|
||||
rw_midtextureslide = ceilingfrontslide;
|
||||
rw_midtextureslide = FixedMul(ceilingfrontslide, scaley);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -2618,13 +2666,13 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
|||
else if (linedef->flags & ML_DONTPEGBOTTOM)
|
||||
{
|
||||
rw_midtexturemid = FixedMul(worldbottom, scaley);
|
||||
rw_midtextureslide = floorfrontslide;
|
||||
rw_midtextureslide = FixedMul(floorfrontslide, scaley);
|
||||
}
|
||||
else
|
||||
{
|
||||
// top of texture at top
|
||||
rw_midtexturemid = FixedMul(worldtop, scaley) + texheight;
|
||||
rw_midtextureslide = ceilingfrontslide;
|
||||
rw_midtextureslide = FixedMul(ceilingfrontslide, scaley);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2833,15 +2881,16 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
|||
{
|
||||
// top of texture at top
|
||||
rw_toptexturemid = worldtop;
|
||||
rw_toptextureslide = ceilingfrontslide;
|
||||
rw_toptextureslide = FixedMul(ceilingfrontslide, abs(rw_toptexturescaley));
|
||||
}
|
||||
else
|
||||
{
|
||||
rw_toptexturemid = worldhigh + texheight;
|
||||
rw_toptextureslide = ceilingbackslide;
|
||||
rw_toptextureslide = FixedMul(ceilingbackslide, abs(rw_toptexturescaley));
|
||||
}
|
||||
|
||||
rw_toptexturemid = FixedMul(rw_toptexturemid, abs(rw_toptexturescaley));
|
||||
rw_toptexturemid += toprowoffset;
|
||||
}
|
||||
|
||||
// check BOTTOM TEXTURE
|
||||
|
|
@ -2872,20 +2921,18 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
|||
// bottom of texture at bottom
|
||||
// top of texture at top
|
||||
rw_bottomtexturemid = worldbottom;
|
||||
rw_bottomtextureslide = floorfrontslide;
|
||||
rw_bottomtextureslide = FixedMul(floorfrontslide, abs(rw_bottomtexturescaley));
|
||||
}
|
||||
else
|
||||
{
|
||||
// top of texture at top
|
||||
rw_bottomtexturemid = worldlow;
|
||||
rw_bottomtextureslide = floorbackslide;
|
||||
rw_bottomtextureslide = FixedMul(floorbackslide, abs(rw_bottomtexturescaley));
|
||||
}
|
||||
|
||||
rw_bottomtexturemid = FixedMul(rw_bottomtexturemid, abs(rw_bottomtexturescaley));
|
||||
}
|
||||
|
||||
rw_toptexturemid += toprowoffset;
|
||||
rw_bottomtexturemid += botrowoffset;
|
||||
}
|
||||
|
||||
// allocate space for masked texture tables
|
||||
R_AllocTextureColumnTables(rw_stopx - start);
|
||||
|
|
@ -3136,6 +3183,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
|||
rw_midtexturemid = FixedMul(rw_midtexturemid, abs(rw_midtexturescaley));
|
||||
rw_midtextureback = FixedMul(rw_midtextureback, abs(rw_midtexturescaley));
|
||||
|
||||
rw_midtextureslide = FixedMul(rw_midtextureslide, abs(rw_midtexturescaley));
|
||||
rw_midtexturebackslide = FixedMul(rw_midtexturebackslide, abs(rw_midtexturescaley));
|
||||
|
||||
rw_midtexturemid += sidedef->rowoffset + sidedef->offsety_mid;
|
||||
rw_midtextureback += sidedef->rowoffset + sidedef->offsety_mid;
|
||||
}
|
||||
|
|
@ -3686,6 +3736,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
|||
// Render up to four extra textures when everything is done
|
||||
if (hasoverlaytexture)
|
||||
{
|
||||
mfloorclip = overlayopening[1];
|
||||
mceilingclip = overlayopening[0];
|
||||
|
||||
for (i = 0; i < NUM_WALL_OVERLAYS; i++)
|
||||
{
|
||||
if (overlaytexture[i])
|
||||
|
|
|
|||
|
|
@ -2752,6 +2752,66 @@ static void R_SortVisSprites(vissprite_t* vsprsortedhead, UINT32 start, UINT32 e
|
|||
}
|
||||
}
|
||||
|
||||
static fixed_t R_GetHighestSidedefTexture(side_t *side)
|
||||
{
|
||||
fixed_t highest = INT32_MIN;
|
||||
|
||||
for (unsigned i = 0; i < NUM_WALL_OVERLAYS; i++)
|
||||
{
|
||||
INT32 texnum = R_GetTextureNum(side->overlays[i].texture);
|
||||
if (texnum <= 0 || texnum >= numtextures)
|
||||
continue;
|
||||
|
||||
fixed_t high = side->rowoffset + side->overlays[i].offsety;
|
||||
if (high > highest)
|
||||
highest = high;
|
||||
}
|
||||
|
||||
if (highest <= 0)
|
||||
return 0;
|
||||
|
||||
return highest;
|
||||
}
|
||||
|
||||
static fixed_t R_GetLowestSidedefTexture(side_t *side)
|
||||
{
|
||||
fixed_t lowest = INT32_MIN;
|
||||
|
||||
for (unsigned i = 0; i < NUM_WALL_OVERLAYS; i++)
|
||||
{
|
||||
INT32 texnum = R_GetTextureNum(side->overlays[i].texture);
|
||||
if (texnum <= 0 || texnum >= numtextures)
|
||||
continue;
|
||||
|
||||
fixed_t low = side->rowoffset + side->overlays[i].offsety + FixedMul(textureheight[texnum], FixedDiv(FRACUNIT, abs(side->overlays[i].scaley)));
|
||||
if (low > lowest)
|
||||
lowest = low;
|
||||
}
|
||||
|
||||
if (lowest <= 0)
|
||||
return 0;
|
||||
|
||||
return lowest;
|
||||
}
|
||||
|
||||
static fixed_t R_GetFFloorTopZAt(const drawseg_t *ds, const ffloor_t *pfloor, fixed_t x, fixed_t y)
|
||||
{
|
||||
side_t *side = R_GetFFloorSide(ds->curline, pfloor);
|
||||
if (side->flags & SIDEFLAG_HASEDGETEXTURES)
|
||||
return P_GetFFloorTopZAt(pfloor, x, y) + R_GetHighestSidedefTexture(side);
|
||||
|
||||
return P_GetFFloorTopZAt(pfloor, x, y);
|
||||
}
|
||||
|
||||
static fixed_t R_GetFFloorBottomZAt(const drawseg_t *ds, const ffloor_t *pfloor, fixed_t x, fixed_t y)
|
||||
{
|
||||
side_t *side = R_GetFFloorSide(ds->curline, pfloor);
|
||||
if (side->flags & SIDEFLAG_HASEDGETEXTURES)
|
||||
return P_GetFFloorBottomZAt(pfloor, x, y) - R_GetLowestSidedefTexture(side);
|
||||
|
||||
return P_GetFFloorBottomZAt(pfloor, x, y);
|
||||
}
|
||||
|
||||
//
|
||||
// R_CreateDrawNodes
|
||||
// Creates and sorts a list of drawnodes for the scene being rendered.
|
||||
|
|
@ -2950,10 +3010,10 @@ static void R_CreateDrawNodes(maskcount_t* mask, drawnode_t* head, boolean temps
|
|||
if (scale <= rover->sortscale)
|
||||
continue;
|
||||
|
||||
topplaneobjectz = P_GetFFloorTopZAt (r2->ffloor, rover->gx, rover->gy);
|
||||
topplanecameraz = P_GetFFloorTopZAt (r2->ffloor, viewx, viewy);
|
||||
botplaneobjectz = P_GetFFloorBottomZAt(r2->ffloor, rover->gx, rover->gy);
|
||||
botplanecameraz = P_GetFFloorBottomZAt(r2->ffloor, viewx, viewy);
|
||||
topplaneobjectz = R_GetFFloorTopZAt (r2->thickseg, r2->ffloor, rover->gx, rover->gy);
|
||||
topplanecameraz = R_GetFFloorTopZAt (r2->thickseg, r2->ffloor, viewx, viewy);
|
||||
botplaneobjectz = R_GetFFloorBottomZAt(r2->thickseg, r2->ffloor, rover->gx, rover->gy);
|
||||
botplanecameraz = R_GetFFloorBottomZAt(r2->thickseg, r2->ffloor, viewx, viewy);
|
||||
|
||||
if ((topplanecameraz > viewz && botplanecameraz < viewz) ||
|
||||
(topplanecameraz < viewz && rover->gzt < topplaneobjectz) ||
|
||||
|
|
|
|||
Loading…
Reference in a new issue