diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c index b5473abc3..aad2615d5 100644 --- a/src/hardware/hw_main.c +++ b/src/hardware/hw_main.c @@ -3755,7 +3755,11 @@ static void HWR_DrawSpriteShadow(gr_vissprite_t *spr, GLPatch_t *gpatch, float t FOutVector swallVerts[4]; FSurfaceInfo sSurf; fixed_t floorheight, mobjfloor; + pslope_t *floorslope; + fixed_t slopez; float offset = 0; + + R_GetShadowZ(spr->mobj, &floorslope); mobjfloor = HWR_OpaqueFloorAtPos( spr->mobj->x, spr->mobj->y, @@ -3849,6 +3853,14 @@ static void HWR_DrawSpriteShadow(gr_vissprite_t *spr, GLPatch_t *gpatch, float t swallVerts[0].z = spr->z1 + offset * gr_viewsin; swallVerts[1].z = spr->z2 + offset * gr_viewsin; } + + if (floorslope) + for (int i = 0; i < 4; i++) + { + slopez = P_GetZAt(floorslope, FLOAT_TO_FIXED(swallVerts[i].x), FLOAT_TO_FIXED(swallVerts[i].z)); + swallVerts[i].y = FIXED_TO_FLOAT(slopez) + 0.05f; + } + if (spr->flip) { diff --git a/src/p_slopes.c b/src/p_slopes.c index 37f671599..4e8918536 100644 --- a/src/p_slopes.c +++ b/src/p_slopes.c @@ -789,6 +789,11 @@ fixed_t P_GetFFloorBottomZAt(const ffloor_t *ffloor, fixed_t x, fixed_t y) return *ffloor->b_slope ? P_GetZAt(*ffloor->b_slope, x, y) : *ffloor->bottomheight; } +// Returns the height of the light list at (x, y) +fixed_t P_GetLightZAt(const lightlist_t *light, fixed_t x, fixed_t y) +{ + return light->slope ? P_GetZAt(light->slope, x, y) : light->height; +} // // P_QuantizeMomentumToSlope diff --git a/src/p_slopes.h b/src/p_slopes.h index 9f736c751..57683d6e1 100644 --- a/src/p_slopes.h +++ b/src/p_slopes.h @@ -41,6 +41,9 @@ fixed_t P_GetSectorCeilingZAt(const sector_t *sector, fixed_t x, fixed_t y); fixed_t P_GetFFloorTopZAt (const ffloor_t *ffloor, fixed_t x, fixed_t y); fixed_t P_GetFFloorBottomZAt(const ffloor_t *ffloor, fixed_t x, fixed_t y); +// Returns the height of the light list at (x, y) +fixed_t P_GetLightZAt(const lightlist_t *light, fixed_t x, fixed_t y); + // Lots of physics-based bullshit void P_QuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope); void P_ReverseQuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope); diff --git a/src/r_things.c b/src/r_things.c index 602dd3545..86588da82 100644 --- a/src/r_things.c +++ b/src/r_things.c @@ -1168,6 +1168,125 @@ static void R_SplitSprite(vissprite_t *sprite, mobj_t *thing) } } +// R_GetShadowZ(thing, shadowslope) +// Get the first visible floor below the object for shadows +// shadowslope is filled with the floor's slope, if provided +// +fixed_t R_GetShadowZ(mobj_t *thing, pslope_t **shadowslope) +{ + boolean isflipped = thing->eflags & MFE_VERTICALFLIP; + fixed_t z, groundz = isflipped ? INT32_MAX : INT32_MIN; + pslope_t *slope, *groundslope = NULL; + msecnode_t *node; + sector_t *sector; + ffloor_t *rover; +#define CHECKZ (isflipped ? z > thing->z+thing->height/2 && z < groundz : z < thing->z+thing->height/2 && z > groundz) + + for (node = thing->touching_sectorlist; node; node = node->m_sectorlist_next) + { + sector = node->m_sector; + + slope = sector->heightsec != -1 ? NULL : (isflipped ? sector->c_slope : sector->f_slope); + + if (sector->heightsec != -1) + z = isflipped ? sectors[sector->heightsec].ceilingheight : sectors[sector->heightsec].floorheight; + else + z = isflipped ? P_GetSectorCeilingZAt(sector, thing->x, thing->y) : P_GetSectorFloorZAt(sector, thing->x, thing->y); + + if CHECKZ + { + groundz = z; + groundslope = slope; + } + + if (sector->ffloors) + for (rover = sector->ffloors; rover; rover = rover->next) + { + if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERPLANES) || (rover->alpha < 90 && !(rover->flags & FF_SWIMMABLE))) + continue; + + z = isflipped ? P_GetFFloorBottomZAt(rover, thing->x, thing->y) : P_GetFFloorTopZAt(rover, thing->x, thing->y); + if CHECKZ + { + groundz = z; + groundslope = isflipped ? *rover->b_slope : *rover->t_slope; + } + } + } + + if (isflipped ? (thing->ceilingz < groundz - (!groundslope ? 0 : FixedMul(abs(groundslope->zdelta), thing->radius*3/2))) + : (thing->floorz > groundz + (!groundslope ? 0 : FixedMul(abs(groundslope->zdelta), thing->radius*3/2)))) + { + groundz = isflipped ? thing->ceilingz : thing->floorz; + groundslope = NULL; + } + +#if 0 // Unfortunately, this drops CEZ2 down to sub-17 FPS on my i7. + // NOTE: this section was not updated to reflect reverse gravity support + // Check polyobjects and see if groundz needs to be altered, for rings only because they don't update floorz + if (thing->type == MT_RING) + { + INT32 xl, xh, yl, yh, bx, by; + + xl = (unsigned)(thing->x - thing->radius - bmaporgx)>>MAPBLOCKSHIFT; + xh = (unsigned)(thing->x + thing->radius - bmaporgx)>>MAPBLOCKSHIFT; + yl = (unsigned)(thing->y - thing->radius - bmaporgy)>>MAPBLOCKSHIFT; + yh = (unsigned)(thing->y + thing->radius - bmaporgy)>>MAPBLOCKSHIFT; + + BMBOUNDFIX(xl, xh, yl, yh); + + validcount++; + + for (by = yl; by <= yh; by++) + for (bx = xl; bx <= xh; bx++) + { + INT32 offset; + polymaplink_t *plink; // haleyjd 02/22/06 + + if (bx < 0 || by < 0 || bx >= bmapwidth || by >= bmapheight) + continue; + + offset = by*bmapwidth + bx; + + // haleyjd 02/22/06: consider polyobject lines + plink = polyblocklinks[offset]; + + while (plink) + { + polyobj_t *po = plink->po; + + if (po->validcount != validcount) // if polyobj hasn't been checked + { + po->validcount = validcount; + + if (!P_MobjInsidePolyobj(po, thing) || !(po->flags & POF_RENDERPLANES)) + { + plink = (polymaplink_t *)(plink->link.next); + continue; + } + + // We're inside it! Yess... + z = po->lines[0]->backsector->ceilingheight; + + if (z < thing->z+thing->height/2 && z > groundz) + { + groundz = z; + groundslope = NULL; + } + } + plink = (polymaplink_t *)(plink->link.next); + } + } + } +#endif + + if (shadowslope != NULL) + *shadowslope = groundslope; + + return groundz; +#undef CHECKZ +} + // // R_ProjectSprite // Generates a vissprite for a thing diff --git a/src/r_things.h b/src/r_things.h index 39be3c3f1..f20e34552 100644 --- a/src/r_things.h +++ b/src/r_things.h @@ -46,6 +46,8 @@ extern fixed_t sprbotscreen; extern fixed_t windowtop; extern fixed_t windowbottom; +fixed_t R_GetShadowZ(mobj_t *thing, pslope_t **shadowslope); + void R_DrawMaskedColumn(column_t *column); void R_SortVisSprites(void);