mirror of
https://git.do.srb2.org/STJr/SRB2.git
synced 2024-11-22 04:21:23 +00:00
Merge branch 'udmf-floor-ceiling-texture-scaling' into 'next'
Floor and ceiling texture scaling See merge request STJr/SRB2!2221
This commit is contained in:
sphere
commit
55d257266d
11 changed files with 319 additions and 200 deletions
|
|
@ -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++)
|
||||
|
|
@ -2725,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;
|
||||
|
|
@ -2760,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
|
||||
{
|
||||
|
|
@ -2775,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;
|
||||
|
||||
|
|
@ -2795,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;
|
||||
}
|
||||
}
|
||||
|
|
@ -2810,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
|
||||
|
|
@ -2858,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);
|
||||
|
|
|
|||
132
src/lua_maplib.c
132
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,14 +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_bot,
|
||||
side_scaley_bot,
|
||||
side_scalex_bottom,
|
||||
side_scaley_bottom,
|
||||
side_toptexture,
|
||||
side_bottomtexture,
|
||||
side_midtexture,
|
||||
|
|
@ -214,14 +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_bot",
|
||||
"scaley_bot",
|
||||
"scalex_bottom",
|
||||
"scaley_bottom",
|
||||
"toptexture",
|
||||
"bottomtexture",
|
||||
"midtexture",
|
||||
|
|
@ -261,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,
|
||||
|
|
@ -287,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
|
||||
|
|
@ -668,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];
|
||||
|
|
@ -692,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;
|
||||
|
|
@ -857,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;
|
||||
|
|
@ -869,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;
|
||||
|
|
@ -1222,9 +1262,11 @@ 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_bottom);
|
||||
return 1;
|
||||
case side_offsety_bottom:
|
||||
case side_offsety_bot:
|
||||
lua_pushfixed(L, side->offsety_bottom);
|
||||
return 1;
|
||||
|
|
@ -1240,10 +1282,10 @@ static int side_get(lua_State *L)
|
|||
case side_scaley_mid:
|
||||
lua_pushfixed(L, side->scaley_mid);
|
||||
return 1;
|
||||
case side_scalex_bot:
|
||||
case side_scalex_bottom:
|
||||
lua_pushfixed(L, side->scalex_bottom);
|
||||
return 1;
|
||||
case side_scaley_bot:
|
||||
case side_scaley_bottom:
|
||||
lua_pushfixed(L, side->scaley_bottom);
|
||||
return 1;
|
||||
case side_toptexture:
|
||||
|
|
@ -1332,9 +1374,11 @@ static int side_set(lua_State *L)
|
|||
side->offsety_mid = luaL_checkfixed(L, 3);
|
||||
break;
|
||||
case side_offsetx_bot:
|
||||
case side_offsetx_bottom:
|
||||
side->offsetx_bottom = luaL_checkfixed(L, 3);
|
||||
break;
|
||||
case side_offsety_bot:
|
||||
case side_offsety_bottom:
|
||||
side->offsety_bottom = luaL_checkfixed(L, 3);
|
||||
break;
|
||||
case side_scalex_top:
|
||||
|
|
@ -1349,10 +1393,10 @@ static int side_set(lua_State *L)
|
|||
case side_scaley_mid:
|
||||
side->scaley_mid = luaL_checkfixed(L, 3);
|
||||
break;
|
||||
case side_scalex_bot:
|
||||
case side_scalex_bottom:
|
||||
side->scalex_bottom = luaL_checkfixed(L, 3);
|
||||
break;
|
||||
case side_scaley_bot:
|
||||
case side_scaley_bottom:
|
||||
side->scaley_bottom = luaL_checkfixed(L, 3);
|
||||
break;
|
||||
case side_toptexture:
|
||||
|
|
@ -2170,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;
|
||||
|
|
@ -2181,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;
|
||||
|
|
@ -2365,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;
|
||||
|
|
@ -2383,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);
|
||||
|
|
|
|||
|
|
@ -867,6 +867,10 @@ static void P_NetUnArchiveWaypoints(void)
|
|||
#define SD_TRIGGERTAG 0x02
|
||||
#define SD_TRIGGERER 0x04
|
||||
#define SD_GRAVITY 0x08
|
||||
#define SD_FXSCALE 0x10
|
||||
#define SD_FYSCALE 0x20
|
||||
#define SD_CXSCALE 0x40
|
||||
#define SD_CYSCALE 0x80
|
||||
|
||||
#define LD_FLAG 0x01
|
||||
#define LD_SPECIAL 0x02
|
||||
|
|
@ -1054,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)
|
||||
|
|
@ -1164,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);
|
||||
}
|
||||
|
|
@ -1285,6 +1305,14 @@ 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]);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
@ -1696,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"))
|
||||
|
|
@ -2685,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)
|
||||
|
|
@ -2920,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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
44
src/r_bsp.c
44
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?
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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])
|
||||
// [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);
|
||||
|
||||
if (span) // Don't divide by zero
|
||||
{
|
||||
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;
|
||||
|
||||
cachedxstep[y] = ds_xstep;
|
||||
cachedystep[y] = ds_ystep;
|
||||
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
|
||||
{
|
||||
distance = cacheddistance[y];
|
||||
ds_xstep = cachedxstep[y];
|
||||
ds_ystep = cachedystep[y];
|
||||
}
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -1981,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)
|
||||
|
|
@ -2014,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)
|
||||
|
|
|
|||
|
|
@ -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])
|
||||
// [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);
|
||||
|
||||
if (span) // Don't divide by zero
|
||||
{
|
||||
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;
|
||||
|
||||
cachedxstep[y] = xstep;
|
||||
cachedystep[y] = ystep;
|
||||
xstep = FixedMul(planesin, planeheight) / span;
|
||||
ystep = FixedMul(planecos, planeheight) / span;
|
||||
}
|
||||
else
|
||||
{
|
||||
distance = cacheddistance[y];
|
||||
xstep = cachedxstep[y];
|
||||
ystep = cachedystep[y];
|
||||
}
|
||||
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)
|
||||
|
|
|
|||
Loading…
Reference in a new issue