#include #include "templates.h" #include "doomdef.h" #include "sbar.h" #include "r_data/r_translate.h" #include "r_swrenderer2.h" #include "r_draw.h" #include "r_plane.h" // for yslope #include "r_sky.h" // for skyflatnum #include "r_things.h" // for pspritexscale EXTERN_CVAR(Bool, r_drawplayersprites) EXTERN_CVAR(Bool, r_deathcamera) EXTERN_CVAR(Bool, st_scale) DVector3 ViewPosTransform::WorldToEye(const DVector3 &worldPoint) const { double tr_x = worldPoint.X - ViewPos.X; double tr_y = worldPoint.Y - ViewPos.Y; double tr_z = worldPoint.Z - ViewPos.Z; double tx = tr_x * ViewSin - tr_y * ViewCos; double tz = tr_x * ViewTanCos + tr_y * ViewTanSin; return DVector3(tx, tr_z, tz); } DVector3 ViewPosTransform::EyeToViewport(const DVector3 &eyePoint) const { double rcp_z = 1.0 / eyePoint.Z; return DVector3(eyePoint.X * rcp_z, eyePoint.Y * rcp_z, rcp_z); } DVector3 ViewPosTransform::ViewportToScreen(const DVector3 &viewportPoint) const { return DVector3(CenterX + viewportPoint.X * CenterX, CenterY - viewportPoint.Y * InvZtoScale, viewportPoint.Z); } double ViewPosTransform::ScreenXToEye(int x, double z) const { return (x + 0.5 - CenterX) / CenterX * z; } double ViewPosTransform::ScreenYToEye(int y, double z) const { return -(y + 0.5 - CenterY) / InvZtoScale * z; } ///////////////////////////////////////////////////////////////////////////// WallCoords::WallCoords(const ViewPosTransform &transform, const DVector2 &v1, const DVector2 &v2, double ceil1, double floor1, double ceil2, double floor2) : Transform(transform) { // Transform wall to eye space DVector3 top1 = transform.WorldToEye(DVector3(v1, ceil1)); DVector3 top2 = transform.WorldToEye(DVector3(v2, ceil2)); DVector3 bottom1 = transform.WorldToEye(DVector3(v1, floor1)); DVector3 bottom2 = transform.WorldToEye(DVector3(v2, floor2)); double clipNearZ = transform.NearZ(); // Is entire wall behind znear clipping plane? If so, wall is culled if ((top1.Z < clipNearZ && top2.Z < clipNearZ)) return; PlaneNormal = (top2 - top1) ^ (top1 - bottom1); PlaneD = -(PlaneNormal | top1); // Clip wall to znear clipping plane if (top1.Z < clipNearZ) { double t = (clipNearZ - top1.Z) / (top2.Z - top1.Z); top1 = Mix(top1, top2, t); bottom1 = Mix(bottom1, bottom2, t); VaryingXScale = 1.0 - t; VaryingXOffset = t; } else if (top2.Z < clipNearZ) { double t = (clipNearZ - top1.Z) / (top2.Z - top1.Z); top2 = Mix(top1, top2, t); bottom2 = Mix(bottom1, bottom2, t); VaryingXScale = t; VaryingXOffset = 0.0; } NearZ = MIN(top1.Z, top2.Z); FarZ = MAX(top1.Z, top2.Z); // Transform to screen coordinates ScreenTopLeft = transform.EyeToScreen(top1); ScreenTopRight = transform.EyeToScreen(top2); ScreenBottomLeft = transform.EyeToScreen(bottom1); ScreenBottomRight = transform.EyeToScreen(bottom2); if (ScreenTopLeft.X > ScreenTopRight.X) { std::swap(ScreenTopLeft, ScreenTopRight); std::swap(ScreenBottomLeft, ScreenBottomRight); } ScreenX1 = xs_RoundToInt(MAX(ScreenTopLeft.X, 0.0)); ScreenX2 = xs_RoundToInt(MIN(ScreenTopRight.X, (double)viewwidth)); ScreenY1 = xs_RoundToInt(MAX(MIN(ScreenTopLeft.Y, ScreenTopRight.Y), 0.0)); ScreenY2 = xs_RoundToInt(MIN(MAX(ScreenBottomLeft.Y, ScreenBottomRight.Y), (double)viewheight)); // Cull if nothing of the wall is visible if (ScreenX2 <= ScreenX1 || ScreenY2 <= ScreenY1) return; RcpDeltaScreenX = 1.0 / (ScreenTopRight.X - ScreenTopLeft.X); Culled = false; } DVector3 WallCoords::Mix(const DVector3 &a, const DVector3 &b, double t) { double invt = 1.0 - t; return DVector3(a.X * invt + b.X * t, a.Y * invt + b.Y * t, a.Z * invt + b.Z * t); } double WallCoords::Mix(double a, double b, double t) { return a * (1.0 - t) + b * t; } short WallCoords::Y1(int x) const { double t = (x + 0.5 - ScreenTopLeft.X) * RcpDeltaScreenX; return (short)MAX(xs_RoundToInt(Mix(ScreenTopLeft.Y, ScreenTopRight.Y, t)), 0); } short WallCoords::Y2(int x) const { double t = (x + 0.5 - ScreenBottomLeft.X) * RcpDeltaScreenX; return (short)MIN(xs_RoundToInt(Mix(ScreenBottomLeft.Y, ScreenBottomRight.Y, t)), viewheight); } double WallCoords::Z(int x) const { double t = (x + 0.5 - ScreenTopLeft.X) * RcpDeltaScreenX; double rcp_z = Mix(ScreenTopLeft.Z, ScreenTopRight.Z, t); return 1.0 / rcp_z; } double WallCoords::VaryingX(int x, double start, double end) const { double t = (x + 0.5 - ScreenTopLeft.X) * RcpDeltaScreenX; double rcp_z = Mix(ScreenTopLeft.Z, ScreenTopRight.Z, t); double t2 = VaryingXOffset + t / rcp_z * ScreenTopRight.Z * VaryingXScale; return Mix(start, end, t2); } double WallCoords::VaryingY(int x, int y, double start, double end) const { double t = (x + 0.5 - ScreenTopLeft.X) * RcpDeltaScreenX; double y1 = Mix(ScreenTopLeft.Y, ScreenTopRight.Y, t); double y2 = Mix(ScreenBottomLeft.Y, ScreenBottomRight.Y, t); if (y1 == y2 || y1 == -y2) return start; double t2 = (y + 0.5 - y1) / (y2 - y1); return Mix(start, end, t2); } ///////////////////////////////////////////////////////////////////////////// void RenderBsp::Render() { Clip.Clear(0, viewwidth); Planes.Clear(); VisibleSprites.clear(); ScreenSprites.clear(); if (numnodes == 0) RenderSubsector(subsectors); else RenderNode(nodes + numnodes - 1); // The head node is the last node output. Planes.Render(); RenderMaskedObjects(); RenderPlayerSprites(); RenderScreenSprites(); // To do: should be called by FSoftwareRenderer::DrawRemainingPlayerSprites instead of here } void RenderBsp::RenderScreenSprites() { for (auto &sprite : ScreenSprites) sprite.Render(); } void RenderBsp::RenderMaskedObjects() { Clip.DrawMaskedWall = [&](short x1, short x2, int drawIndex, const short *clipTop, const short *clipBottom) { VisibleMaskedWalls[drawIndex].RenderMasked(x1, x2, clipTop, clipBottom); }; std::stable_sort(VisibleSprites.begin(), VisibleSprites.end(), [](const auto &a, const auto &b) { return a.EyePos.Z > b.EyePos.Z; }); for (auto &sprite : VisibleSprites) sprite.Render(&Clip); Clip.RenderMaskedWalls(); } void RenderBsp::RenderPlayerSprites() { if (!r_drawplayersprites || !camera || !camera->player || (players[consoleplayer].cheats & CF_CHASECAM) || (r_deathcamera && camera->health <= 0)) return; float bobx, boby; P_BobWeapon(camera->player, &bobx, &boby, r_TicFracF); // Interpolate the main weapon layer once so as to be able to add it to other layers. double wx, wy; DPSprite *weapon = camera->player->FindPSprite(PSP_WEAPON); if (weapon) { if (weapon->firstTic) { wx = weapon->x; wy = weapon->y; } else { wx = weapon->oldx + (weapon->x - weapon->oldx) * r_TicFracF; wy = weapon->oldy + (weapon->y - weapon->oldy) * r_TicFracF; } } else { wx = 0; wy = 0; } for (DPSprite *sprite = camera->player->psprites; sprite != nullptr; sprite = sprite->GetNext()) { // [RH] Don't draw the targeter's crosshair if the player already has a crosshair set. // It's possible this psprite's caller is now null but the layer itself hasn't been destroyed // because it didn't tick yet (if we typed 'take all' while in the console for example). // In this case let's simply not draw it to avoid crashing. if ((sprite->GetID() != PSP_TARGETCENTER || CrosshairImage == nullptr) && sprite->GetCaller() != nullptr) { RenderPlayerSprite(sprite, camera, bobx, boby, wx, wy, r_TicFracF); } } } void RenderBsp::RenderPlayerSprite(DPSprite *sprite, AActor *owner, float bobx, float boby, double wx, double wy, double ticfrac) { // decide which patch to use if ((unsigned)sprite->GetSprite() >= (unsigned)sprites.Size()) { DPrintf(DMSG_ERROR, "RenderPlayerSprite: invalid sprite number %i\n", sprite->GetSprite()); return; } spritedef_t *def = &sprites[sprite->GetSprite()]; if (sprite->GetFrame() >= def->numframes) { DPrintf(DMSG_ERROR, "RenderPlayerSprite: invalid sprite frame %i : %i\n", sprite->GetSprite(), sprite->GetFrame()); return; } spriteframe_t *frame = &SpriteFrames[def->spriteframes + sprite->GetFrame()]; FTextureID picnum = frame->Texture[0]; bool flip = (frame->Flip & 1) != 0; FTexture *tex = TexMan(picnum); if (tex->UseType == FTexture::TEX_Null) return; // Can't interpolate the first tic. if (sprite->firstTic) { sprite->firstTic = false; sprite->oldx = sprite->x; sprite->oldy = sprite->y; } double sx = sprite->oldx + (sprite->x - sprite->oldx) * ticfrac; double sy = sprite->oldy + (sprite->y - sprite->oldy) * ticfrac; if (sprite->Flags & PSPF_ADDBOB) { sx += bobx; sy += boby; } if (sprite->Flags & PSPF_ADDWEAPON && sprite->GetID() != PSP_WEAPON) { sx += wx; sy += wy; } // calculate edges of the shape double tx = sx - BaseXCenter; tx -= tex->GetScaledLeftOffset(); int x1 = xs_RoundToInt(CenterX + tx * pspritexscale); // off the right side if (x1 > viewwidth) return; tx += tex->GetScaledWidth(); int x2 = xs_RoundToInt(CenterX + tx * pspritexscale); // off the left side if (x2 <= 0) return; double texturemid = (BaseYCenter - sy) * tex->Scale.Y + tex->TopOffset; // Adjust PSprite for fullscreen views if (camera->player && (RenderTarget != screen || viewheight == RenderTarget->GetHeight() || (RenderTarget->GetWidth() > (BaseXCenter * 2) && !st_scale))) { AWeapon *weapon = dyn_cast(sprite->GetCaller()); if (weapon != nullptr && weapon->YAdjust != 0) { if (RenderTarget != screen || viewheight == RenderTarget->GetHeight()) { texturemid -= weapon->YAdjust; } else { texturemid -= StatusBar->GetDisplacement() * weapon->YAdjust; } } } // Move the weapon down for 1280x1024. if (sprite->GetID() < PSP_TARGETCENTER) { texturemid -= AspectPspriteOffset(WidescreenRatio); } int clipped_x1 = MAX(x1, 0); int clipped_x2 = MIN(x2, viewwidth); double xscale = pspritexscale / tex->Scale.X; double yscale = pspriteyscale / tex->Scale.Y; uint32_t translation = 0; // [RH] Use default colors double xiscale, startfrac; if (flip) { xiscale = -pspritexiscale * tex->Scale.X; startfrac = 1; } else { xiscale = pspritexiscale * tex->Scale.X; startfrac = 0; } if (clipped_x1 > x1) startfrac += xiscale * (clipped_x1 - x1); bool noaccel = false; FDynamicColormap *basecolormap = viewsector->ColorMap; FDynamicColormap *colormap_to_use = basecolormap; visstyle_t visstyle; visstyle.ColormapNum = 0; visstyle.BaseColormap = basecolormap; visstyle.Alpha = 0; visstyle.RenderStyle = STYLE_Normal; bool foggy = false; int actualextralight = foggy ? 0 : extralight << 4; int spriteshade = LIGHT2SHADE(owner->Sector->lightlevel + actualextralight); double minz = double((2048 * 4) / double(1 << 20)); visstyle.ColormapNum = GETPALOOKUP(r_SpriteVisibility / minz, spriteshade); if (sprite->GetID() < PSP_TARGETCENTER) { // Lots of complicated style and noaccel stuff } // Check for hardware-assisted 2D. If it's available, and this sprite is not // fuzzy, don't draw it until after the switch to 2D mode. if (!noaccel && RenderTarget == screen && (DFrameBuffer *)screen->Accel2D) { FRenderStyle style = visstyle.RenderStyle; style.CheckFuzz(); if (style.BlendOp != STYLEOP_Fuzz) { ScreenSprite screenSprite; screenSprite.Pic = tex; screenSprite.X1 = viewwindowx + x1; screenSprite.Y1 = viewwindowy + viewheight / 2 - texturemid * yscale - 0.5; screenSprite.Width = tex->GetWidth() * xscale; screenSprite.Height = tex->GetHeight() * yscale; screenSprite.Translation = TranslationToTable(translation); screenSprite.Flip = xiscale < 0; screenSprite.visstyle = visstyle; screenSprite.Colormap = colormap_to_use; ScreenSprites.push_back(screenSprite); return; } } //R_DrawVisSprite(vis); } bool RenderBsp::IsThingCulled(AActor *thing) { FIntCVar *cvar = thing->GetClass()->distancecheck; if (cvar != nullptr && *cvar >= 0) { double dist = (thing->Pos() - ViewPos).LengthSquared(); double check = (double)**cvar; if (dist >= check * check) return true; } // Don't waste time projecting sprites that are definitely not visible. if (thing == nullptr || (thing->renderflags & RF_INVISIBLE) || !thing->RenderStyle.IsVisible(thing->Alpha) || !thing->IsVisibleToPlayer()) { return true; } return false; } void RenderBsp::AddSprite(AActor *thing) { if (IsThingCulled(thing)) return; DVector3 pos = thing->InterpolatedPosition(r_TicFracF); pos.Z += thing->GetBobOffset(r_TicFracF); DVector3 eyePos = Transform.WorldToEye(pos); // thing is behind view plane? if (eyePos.Z < Transform.NearZ()) return; // too far off the side? if (fabs(eyePos.X / 64) > eyePos.Z) return; VisibleSprites.push_back({ thing, eyePos }); } void RenderBsp::AddWallSprite(AActor *thing) { if (IsThingCulled(thing)) return; } void RenderBsp::RenderSubsector(subsector_t *sub) { sector_t *frontsector = sub->sector; frontsector->MoreFlags |= SECF_DRAWN; for (AActor *thing = sub->sector->thinglist; thing != nullptr; thing = thing->snext) { if ((thing->renderflags & RF_SPRITETYPEMASK) == RF_WALLSPRITE) AddWallSprite(thing); else AddSprite(thing); } for (uint32_t i = 0; i < sub->numlines; i++) { seg_t *line = &sub->firstline[i]; if (line->sidedef == NULL || !(line->sidedef->Flags & WALLF_POLYOBJ)) AddLine(line, frontsector); } } void RenderBsp::AddLine(seg_t *line, sector_t *frontsector) { // Reject lines not facing viewer DVector2 pt1 = line->v1->fPos() - ViewPos; DVector2 pt2 = line->v2->fPos() - ViewPos; if (pt1.Y * (pt1.X - pt2.X) + pt1.X * (pt2.Y - pt1.Y) >= 0) return; double frontceilz1 = frontsector->ceilingplane.ZatPoint(line->v1); double frontfloorz1 = frontsector->floorplane.ZatPoint(line->v1); double frontceilz2 = frontsector->ceilingplane.ZatPoint(line->v2); double frontfloorz2 = frontsector->floorplane.ZatPoint(line->v2); WallCoords entireWall(Transform, line->v1->fPos(), line->v2->fPos(), frontceilz1, frontfloorz1, frontceilz2, frontfloorz2); if (entireWall.Culled) return; VisiblePlaneKey ceilingPlaneKey(frontsector->GetTexture(sector_t::ceiling), frontsector->ColorMap, frontsector->lightlevel, frontsector->ceilingplane, frontsector->planes[sector_t::ceiling].xform); VisiblePlaneKey floorPlaneKey(frontsector->GetTexture(sector_t::floor), frontsector->ColorMap, frontsector->lightlevel, frontsector->floorplane, frontsector->planes[sector_t::floor].xform); RenderWall wall; wall.Line = line; wall.Colormap = frontsector->ColorMap; wall.Masked = false; if (line->backsector == nullptr) { Planes.MarkCeilingPlane(ceilingPlaneKey, Clip, entireWall); Planes.MarkFloorPlane(floorPlaneKey, Clip, entireWall); wall.Coords = entireWall; wall.TopZ = frontceilz1; wall.BottomZ = frontfloorz1; wall.UnpeggedCeil = frontceilz1; wall.Texpart = side_t::mid; wall.Render(Clip); Clip.MarkSegmentCulled(entireWall, -1); } else { sector_t *backsector = (line->backsector != line->frontsector) ? line->backsector : line->frontsector; double backceilz1 = backsector->ceilingplane.ZatPoint(line->v1); double backfloorz1 = backsector->floorplane.ZatPoint(line->v1); double backceilz2 = backsector->ceilingplane.ZatPoint(line->v2); double backfloorz2 = backsector->floorplane.ZatPoint(line->v2); double topceilz1 = frontceilz1; double topceilz2 = frontceilz2; double topfloorz1 = MIN(backceilz1, frontceilz1); double topfloorz2 = MIN(backceilz2, frontceilz2); double bottomceilz1 = MAX(frontfloorz1, backfloorz1); double bottomceilz2 = MAX(frontfloorz2, backfloorz2); double bottomfloorz1 = frontfloorz1; double bottomfloorz2 = frontfloorz2; double middleceilz1 = topfloorz1; double middleceilz2 = topfloorz2; double middlefloorz1 = MIN(bottomceilz1, middleceilz1); double middlefloorz2 = MIN(bottomceilz2, middleceilz2); bool bothSkyCeiling = frontsector->GetTexture(sector_t::ceiling) == skyflatnum && backsector->GetTexture(sector_t::ceiling) == skyflatnum; bool bothSkyFloor = frontsector->GetTexture(sector_t::floor) == skyflatnum && backsector->GetTexture(sector_t::floor) == skyflatnum; int maskedWallIndex = -1; if ((topceilz1 > topfloorz1 || topceilz2 > topfloorz2) && !bothSkyCeiling && line->sidedef) { WallCoords topwall(Transform, line->v1->fPos(), line->v2->fPos(), topceilz1, topfloorz1, topceilz2, topfloorz2); if (!topwall.Culled) { wall.Coords = topwall; wall.TopZ = topceilz1; wall.BottomZ = topfloorz1; wall.UnpeggedCeil = topceilz1; wall.Texpart = side_t::top; wall.Render(Clip); } } if ((bottomfloorz1 < bottomceilz1 || bottomfloorz2 < bottomceilz2) && !bothSkyFloor && line->sidedef) { WallCoords bottomwall(Transform, line->v1->fPos(), line->v2->fPos(), bottomceilz1, bottomfloorz2, bottomceilz2, bottomfloorz2); if (!bottomwall.Culled) { wall.Coords = bottomwall; wall.TopZ = bottomceilz1; wall.BottomZ = bottomfloorz2; wall.UnpeggedCeil = topceilz1; wall.Texpart = side_t::bottom; wall.Render(Clip); } } WallCoords midwall(Transform, line->v1->fPos(), line->v2->fPos(), middleceilz1, middlefloorz1, middleceilz2, middlefloorz2); if (!midwall.Culled && line->sidedef) { FTexture *midtex = TexMan(line->sidedef->GetTexture(side_t::mid), true); if (midtex && midtex->UseType != FTexture::TEX_Null) { DVector3 v1 = Transform.WorldToEye({ line->v1->fPos(), 0.0 }); DVector3 v2 = Transform.WorldToEye({ line->v2->fPos(), 0.0 }); wall.Coords = midwall; wall.TopZ = middleceilz1; wall.BottomZ = middlefloorz1; wall.UnpeggedCeil = topceilz1; wall.Texpart = side_t::mid; wall.Masked = true; maskedWallIndex = (int)VisibleMaskedWalls.size(); VisibleMaskedWalls.push_back(wall); } } if (!bothSkyCeiling && !bothSkyFloor) { Planes.MarkCeilingPlane(ceilingPlaneKey, Clip, entireWall); Planes.MarkFloorPlane(floorPlaneKey, Clip, entireWall); if (!midwall.Culled) Clip.ClipVertical(midwall, maskedWallIndex); else Clip.MarkSegmentCulled(entireWall, maskedWallIndex); } else if (bothSkyCeiling) { Planes.MarkFloorPlane(floorPlaneKey, Clip, entireWall); if (!midwall.Culled) Clip.ClipBottom(midwall, maskedWallIndex); else Clip.MarkSegmentCulled(entireWall, maskedWallIndex); } else if (bothSkyFloor) { Planes.MarkCeilingPlane(ceilingPlaneKey, Clip, entireWall); if (!midwall.Culled) Clip.ClipTop(midwall, maskedWallIndex); else Clip.MarkSegmentCulled(entireWall, maskedWallIndex); } } } void RenderBsp::RenderNode(void *node) { while (!((size_t)node & 1)) // Keep going until found a subsector { node_t *bsp = (node_t *)node; // Decide which side the view point is on. int side = PointOnSide(ViewPos, bsp); // Recursively divide front space (toward the viewer). RenderNode(bsp->children[side]); // Possibly divide back space (away from the viewer). side ^= 1; if (!CheckBBox(bsp->bbox[side])) return; node = bsp->children[side]; } RenderSubsector((subsector_t *)((BYTE *)node - 1)); } int RenderBsp::PointOnSide(const DVector2 &pos, const node_t *node) { return DMulScale32(FLOAT2FIXED(pos.Y) - node->y, node->dx, node->x - FLOAT2FIXED(pos.X), node->dy) > 0; } bool RenderBsp::CheckBBox(float *bspcoord) { static const int checkcoord[12][4] = { { 3,0,2,1 }, { 3,0,2,0 }, { 3,1,2,0 }, { 0 }, { 2,0,2,1 }, { 0,0,0,0 }, { 3,1,3,0 }, { 0 }, { 2,0,3,1 }, { 2,1,3,1 }, { 2,1,3,0 } }; int boxx; int boxy; int boxpos; double x1, y1, x2, y2; double rx1, ry1, rx2, ry2; int sx1, sx2; // Find the corners of the box // that define the edges from current viewpoint. if (ViewPos.X <= bspcoord[BOXLEFT]) boxx = 0; else if (ViewPos.X < bspcoord[BOXRIGHT]) boxx = 1; else boxx = 2; if (ViewPos.Y >= bspcoord[BOXTOP]) boxy = 0; else if (ViewPos.Y > bspcoord[BOXBOTTOM]) boxy = 1; else boxy = 2; boxpos = (boxy << 2) + boxx; if (boxpos == 5) return true; x1 = bspcoord[checkcoord[boxpos][0]] - ViewPos.X; y1 = bspcoord[checkcoord[boxpos][1]] - ViewPos.Y; x2 = bspcoord[checkcoord[boxpos][2]] - ViewPos.X; y2 = bspcoord[checkcoord[boxpos][3]] - ViewPos.Y; // check clip list for an open space // Sitting on a line? if (y1 * (x1 - x2) + x1 * (y2 - y1) >= -EQUAL_EPSILON) return true; rx1 = x1 * ViewSin - y1 * ViewCos; rx2 = x2 * ViewSin - y2 * ViewCos; ry1 = x1 * ViewTanCos + y1 * ViewTanSin; ry2 = x2 * ViewTanCos + y2 * ViewTanSin; /*if (MirrorFlags & RF_XFLIP) { double t = -rx1; rx1 = -rx2; rx2 = t; swapvalues(ry1, ry2); }*/ if (rx1 >= -ry1) { if (rx1 > ry1) return false; // left edge is off the right side if (ry1 == 0) return false; sx1 = xs_RoundToInt(CenterX + rx1 * CenterX / ry1); } else { if (rx2 < -ry2) return false; // wall is off the left side if (rx1 - rx2 - ry2 + ry1 == 0) return false; // wall does not intersect view volume sx1 = 0; } if (rx2 <= ry2) { if (rx2 < -ry2) return false; // right edge is off the left side if (ry2 == 0) return false; sx2 = xs_RoundToInt(CenterX + rx2 * CenterX / ry2); } else { if (rx1 > ry1) return false; // wall is off the right side if (ry2 - ry1 - rx2 + rx1 == 0) return false; // wall does not intersect view volume sx2 = viewwidth; } // Find the first clippost that touches the source post // (adjacent pixels are touching). // Does not cross a pixel. if (sx2 <= sx1) return false; return !Clip.IsSegmentCulled(sx1, sx2); } ///////////////////////////////////////////////////////////////////////////// WallTextureCoords::WallTextureCoords(FTexture *tex, const seg_t *line, side_t::ETexpart texpart, double topz, double bottomz, double unpeggedceil) { CalcU(tex, line, texpart); CalcV(tex, line, texpart, topz, bottomz, unpeggedceil); } void WallTextureCoords::CalcU(FTexture *tex, const seg_t *line, side_t::ETexpart texpart) { double lineLength = line->sidedef->TexelLength; double lineStart = 0.0; bool entireSegment = ((line->linedef->v1 == line->v1) && (line->linedef->v2 == line->v2) || (line->linedef->v2 == line->v1) && (line->linedef->v1 == line->v2)); if (!entireSegment) { lineLength = (line->v2->fPos() - line->v1->fPos()).Length(); lineStart = (line->v1->fPos() - line->linedef->v1->fPos()).Length(); } int texWidth = tex->GetWidth(); double uscale = line->sidedef->GetTextureXScale(texpart) * tex->Scale.X; u1 = lineStart + line->sidedef->GetTextureXOffset(texpart); u2 = u1 + lineLength; u1 *= uscale; u2 *= uscale; u1 /= texWidth; u2 /= texWidth; } void WallTextureCoords::CalcV(FTexture *tex, const seg_t *line, side_t::ETexpart texpart, double topz, double bottomz, double unpeggedceil) { double vscale = line->sidedef->GetTextureYScale(texpart) * tex->Scale.Y; double yoffset = line->sidedef->GetTextureYOffset(texpart); if (tex->bWorldPanning) yoffset *= vscale; switch (texpart) { default: case side_t::mid: CalcVMidPart(tex, line, topz, bottomz, vscale, yoffset); break; case side_t::top: CalcVTopPart(tex, line, topz, bottomz, vscale, yoffset); break; case side_t::bottom: CalcVBottomPart(tex, line, topz, bottomz, unpeggedceil, vscale, yoffset); break; } int texHeight = tex->GetHeight(); v1 /= texHeight; v2 /= texHeight; } void WallTextureCoords::CalcVTopPart(FTexture *tex, const seg_t *line, double topz, double bottomz, double vscale, double yoffset) { bool pegged = (line->linedef->flags & ML_DONTPEGTOP) == 0; if (pegged) // bottom to top { int texHeight = tex->GetHeight(); v1 = -yoffset; v2 = v1 + (topz - bottomz); v1 *= vscale; v2 *= vscale; v1 = texHeight - v1; v2 = texHeight - v2; std::swap(v1, v2); } else // top to bottom { v1 = yoffset; v2 = v1 + (topz - bottomz); v1 *= vscale; v2 *= vscale; } } void WallTextureCoords::CalcVMidPart(FTexture *tex, const seg_t *line, double topz, double bottomz, double vscale, double yoffset) { bool pegged = (line->linedef->flags & ML_DONTPEGBOTTOM) == 0; if (pegged) // top to bottom { v1 = yoffset; v2 = v1 + (topz - bottomz); v1 *= vscale; v2 *= vscale; } else // bottom to top { int texHeight = tex->GetHeight(); v1 = yoffset; v2 = v1 + (topz - bottomz); v1 *= vscale; v2 *= vscale; v1 = texHeight - v1; v2 = texHeight - v2; std::swap(v1, v2); } } void WallTextureCoords::CalcVBottomPart(FTexture *tex, const seg_t *line, double topz, double bottomz, double unpeggedceil, double vscale, double yoffset) { bool pegged = (line->linedef->flags & ML_DONTPEGBOTTOM) == 0; if (pegged) // top to bottom { v1 = yoffset; v2 = v1 + (topz - bottomz); v1 *= vscale; v2 *= vscale; } else { v1 = yoffset + (unpeggedceil - topz); v2 = v1 + (topz - bottomz); v1 *= vscale; v2 *= vscale; } } ///////////////////////////////////////////////////////////////////////////// void RenderClipBuffer::Clear(short left, short right) { SolidSegments.clear(); SolidSegments.reserve(MAXWIDTH / 2 + 2); SolidSegments.push_back({ -0x7fff, left }); SolidSegments.push_back({ right, 0x7fff }); DrawSegments.clear(); ClipValues.clear(); for (int x = left; x < right; x++) { Top[x] = 0; Bottom[x] = viewheight; } } bool RenderClipBuffer::IsSegmentCulled(short x1, short x2) const { int next = 0; while (SolidSegments[next].X2 <= x2) next++; return (x1 >= SolidSegments[next].X1 && x2 <= SolidSegments[next].X2); } void RenderClipBuffer::MarkSegmentCulled(const WallCoords &wallCoords, int drawIndex) { if (wallCoords.Culled) return; VisibleSegmentsIterator it(*this, wallCoords.ScreenX1, wallCoords.ScreenX2); while (it.Step()) { for (short x = it.X1; x < it.X2; x++) { Bottom[x] = Top[x]; } AddDrawSegment(it.X1, it.X2, wallCoords, true, true, drawIndex); } short x1 = wallCoords.ScreenX1; short x2 = wallCoords.ScreenX2; if (x1 >= x2) return; int cur = 1; while (true) { if (SolidSegments[cur].X1 <= x1 && SolidSegments[cur].X2 >= x2) // Already fully marked { break; } else if (cur + 1 != SolidSegments.size() && SolidSegments[cur].X2 >= x1 && SolidSegments[cur].X1 <= x2) // Merge segments { // Find last segment int merge = cur; while (merge + 2 != SolidSegments.size() && SolidSegments[merge + 1].X1 <= x2) merge++; // Apply new merged range SolidSegments[cur].X1 = MIN(SolidSegments[cur].X1, x1); SolidSegments[cur].X2 = MAX(SolidSegments[merge].X2, x2); // Remove additional segments we merged with if (merge > cur) SolidSegments.erase(SolidSegments.begin() + (cur + 1), SolidSegments.begin() + (merge + 1)); break; } else if (SolidSegments[cur].X1 > x1) // Insert new segment { SolidSegments.insert(SolidSegments.begin() + cur, { x1, x2 }); break; } cur++; } } void RenderClipBuffer::ClipVertical(const WallCoords &wallCoords, int drawIndex) { if (wallCoords.Culled) return; VisibleSegmentsIterator it(*this, wallCoords.ScreenX1, wallCoords.ScreenX2); while (it.Step()) { for (short x = it.X1; x < it.X2; x++) { Top[x] = MAX(wallCoords.Y1(x), Top[x]); Bottom[x] = MIN(wallCoords.Y2(x), Bottom[x]); } AddDrawSegment(it.X1, it.X2, wallCoords, true, true, drawIndex); } } void RenderClipBuffer::ClipTop(const WallCoords &wallCoords, int drawIndex) { if (wallCoords.Culled) return; VisibleSegmentsIterator it(*this, wallCoords.ScreenX1, wallCoords.ScreenX2); while (it.Step()) { for (short x = it.X1; x < it.X2; x++) { Top[x] = MAX(wallCoords.Y1(x), Top[x]); } AddDrawSegment(it.X1, it.X2, wallCoords, true, false, drawIndex); } } void RenderClipBuffer::ClipBottom(const WallCoords &wallCoords, int drawIndex) { if (wallCoords.Culled) return; VisibleSegmentsIterator it(*this, wallCoords.ScreenX1, wallCoords.ScreenX2); while (it.Step()) { for (short x = it.X1; x < it.X2; x++) { Bottom[x] = MIN(wallCoords.Y2(x), Bottom[x]); } AddDrawSegment(it.X1, it.X2, wallCoords, false, true, drawIndex); } } void RenderClipBuffer::AddDrawSegment(short x1, short x2, const WallCoords &wall, bool clipTop, bool clipBottom, int drawIndex) { if (drawIndex != -1) // DrawMaskedWall needs both clipping ranges { clipTop = true; clipBottom = true; } DrawSegment segment; segment.X1 = x1; segment.X2 = x2; segment.ClipOffset = (int)ClipValues.size(); segment.ClipTop = clipTop; segment.ClipBottom = clipBottom; segment.PlaneNormal = wall.PlaneNormal; segment.PlaneD = wall.PlaneD; segment.NearZ = wall.NearZ; segment.FarZ = wall.FarZ; segment.DrawIndex = drawIndex; if (clipTop) { ClipValues.insert(ClipValues.end(), Top + x1, Top + x2); } if (clipBottom) { ClipValues.insert(ClipValues.end(), Bottom + x1, Bottom + x2); } DrawSegments.push_back(segment); } void RenderClipBuffer::SetupSpriteClip(short x1, short x2, const DVector3 &pos, bool wallSprite) { for (int i = x1; i < x2; i++) { Top[i] = 0; Bottom[i] = viewheight; } for (auto it = DrawSegments.crbegin(); it != DrawSegments.crend(); ++it) { const auto &segment = *it; int r1 = MAX(segment.X1, x1); int r2 = MIN(segment.X2, x2); if (r2 <= r1) continue; short *clipTop = ClipValues.data() + segment.ClipOffset; short *clipBottom = segment.ClipTop ? clipTop + (segment.X2 - segment.X1) : clipTop; double side = (pos | segment.PlaneNormal) + segment.PlaneD; bool segBehindSprite; if (!wallSprite) segBehindSprite = (segment.NearZ >= pos.Z) || (segment.FarZ >= pos.Z && side <= 0.0); else segBehindSprite = side <= 0.0; if (segBehindSprite) { if (segment.DrawIndex != -1 && DrawMaskedWall) DrawMaskedWall(r1, r2, segment.DrawIndex, clipTop + (r1 - segment.X1), clipBottom + (r1 - segment.X1)); if (segment.ClipTop) { for (int i = r1 - segment.X1; i < r2 - segment.X1; i++) clipTop[i] = 0; } if (segment.ClipBottom) { for (int i = r1 - segment.X1; i < r2 - segment.X1; i++) clipBottom[i] = 0; } } else { if (segment.ClipTop) { for (int x = r1; x < r2; x++) Top[x] = MAX(clipTop[x - segment.X1], Top[x]); } if (segment.ClipBottom) { for (int x = r1; x < r2; x++) Bottom[x] = MIN(clipBottom[x - segment.X1], Bottom[x]); } } } } void RenderClipBuffer::RenderMaskedWalls() { for (int i = 0; i < viewwidth; i++) { Top[i] = 0; Bottom[i] = viewheight; } for (auto it = DrawSegments.crbegin(); it != DrawSegments.crend(); ++it) { const auto &segment = *it; if (segment.DrawIndex != -1 && DrawMaskedWall) { short *clipTop = ClipValues.data() + segment.ClipOffset; short *clipBottom = segment.ClipTop ? clipTop + (segment.X2 - segment.X1) : clipTop; DrawMaskedWall(segment.X1, segment.X2, segment.DrawIndex, clipTop, clipBottom); } } } ///////////////////////////////////////////////////////////////////////////// VisibleSegmentsIterator::VisibleSegmentsIterator(const RenderClipBuffer &buffer, short startx, short endx) : SolidSegments(buffer.SolidSegments), endx(endx) { X1 = startx; X2 = startx; } bool VisibleSegmentsIterator::Step() { if (next == 0) { while (SolidSegments[next].X2 <= X1) next++; if (SolidSegments[next].X1 <= X1) X1 = SolidSegments[next++].X2; X2 = MIN(SolidSegments[next].X1, endx); } else if (X2 == SolidSegments[next].X1 && next + 1 != SolidSegments.size()) { X1 = SolidSegments[next++].X2; X2 = MIN(SolidSegments[next].X1, endx); } else { X1 = X2; } return X1 < X2; } ///////////////////////////////////////////////////////////////////////////// RenderVisiblePlane::RenderVisiblePlane(VisiblePlane *plane, FTexture *tex) { const auto &key = plane->Key; double xscale = key.Transform.xScale * tex->Scale.X; double yscale = key.Transform.yScale * tex->Scale.Y; double planeang = (key.Transform.Angle + key.Transform.baseAngle).Radians(); double cosine = cos(planeang); double sine = sin(planeang); viewx = (key.Transform.xOffs + ViewPos.X * cosine - ViewPos.Y * sine) * xscale; viewy = (key.Transform.yOffs - ViewPos.X * sine - ViewPos.Y * cosine) * yscale; // left to right mapping planeang += (ViewAngle - 90).Radians(); // Scale will be unit scale at FocalLengthX (normally SCREENWIDTH/2) distance double xstep = cos(planeang) / FocalLengthX; double ystep = -sin(planeang) / FocalLengthX; // [RH] flip for mirrors /*if (MirrorFlags & RF_XFLIP) { xstep = -xstep; ystep = -ystep; }*/ planeang += M_PI / 2; cosine = cos(planeang); sine = -sin(planeang); double x = plane->Right - centerx - 0.5; double rightxfrac = xscale * (cosine + x * xstep); double rightyfrac = yscale * (sine + x * ystep); x = plane->Left - centerx - 0.5; double leftxfrac = xscale * (cosine + x * xstep); double leftyfrac = yscale * (sine + x * ystep); basexfrac = rightxfrac; baseyfrac = rightyfrac; xstepscale = (rightxfrac - leftxfrac) / (plane->Right - plane->Left); ystepscale = (rightyfrac - leftyfrac) / (plane->Right - plane->Left); planeheight = fabs(key.Plane.Zat0() - ViewPos.Z); } void RenderVisiblePlane::Step() { basexfrac -= xstepscale; baseyfrac -= ystepscale; } ///////////////////////////////////////////////////////////////////////////// void RenderPlanes::Render() { for (int i = 0; i < NumBuckets; i++) { VisiblePlane *plane = PlaneBuckets[i].get(); while (plane) { RenderPlane(plane); plane = plane->Next.get(); } } } void RenderPlanes::RenderPlane(VisiblePlane *plane) { FTexture *tex = TexMan(plane->Key.Picnum); if (tex->UseType == FTexture::TEX_Null) return; RenderVisiblePlane render(plane, tex); short spanend[MAXHEIGHT]; int x = plane->Right - 1; int t2 = plane->Top[x]; int b2 = plane->Bottom[x]; if (b2 > t2) { clearbufshort(spanend + t2, b2 - t2, x); } for (--x; x >= plane->Left; --x) { int t1 = plane->Top[x]; int b1 = plane->Bottom[x]; const int xr = x + 1; int stop; // Draw any spans that have just closed stop = MIN(t1, b2); while (t2 < stop) { int y = t2++; RenderSpan(y, xr, spanend[y], plane->Key, tex, render); } stop = MAX(b1, t2); while (b2 > stop) { int y = --b2; RenderSpan(y, xr, spanend[y], plane->Key, tex, render); } // Mark any spans that have just opened stop = MIN(t2, b1); while (t1 < stop) { spanend[t1++] = x; } stop = MAX(b2, t2); while (b1 > stop) { spanend[--b1] = x; } t2 = plane->Top[x]; b2 = plane->Bottom[x]; render.Step(); } // Draw any spans that are still open while (t2 < b2) { int y = --b2; RenderSpan(y, plane->Left, spanend[y], plane->Key, tex, render); } } void RenderPlanes::RenderSpan(int y, int x1, int x2, const VisiblePlaneKey &key, FTexture *tex, const RenderVisiblePlane &renderInfo) { if (key.Picnum != skyflatnum) { double distance = renderInfo.planeheight * yslope[y]; double u = distance * renderInfo.basexfrac + renderInfo.viewx; double v = distance * renderInfo.baseyfrac + renderInfo.viewy; double uscale = distance * renderInfo.xstepscale; double vscale = distance * renderInfo.ystepscale; double vis = r_FloorVisibility / renderInfo.planeheight; if (fixedlightlev >= 0) R_SetDSColorMapLight(key.ColorMap, 0, FIXEDLIGHT2SHADE(fixedlightlev)); else if (fixedcolormap) R_SetDSColorMapLight(fixedcolormap, 0, 0); else R_SetDSColorMapLight(key.ColorMap, (float)(vis * fabs(CenterY - y)), LIGHT2SHADE(key.LightLevel)); ds_source = (const BYTE *)tex->GetPixelsBgra(); ds_source_mipmapped = false; ds_xbits = tex->WidthBits; ds_ybits = tex->HeightBits; ds_xfrac = (uint32_t)(u * (1 << (32 - ds_xbits))); ds_yfrac = (uint32_t)(v * (1 << (32 - ds_ybits))); ds_xstep = (uint32_t)(uscale * (1 << (32 - ds_xbits))); ds_ystep = (uint32_t)(vscale * (1 << (32 - ds_ybits))); ds_y = y; ds_x1 = x1; ds_x2 = x2; R_DrawSpan(); } else { tex = TexMan(sky1texture, true); double xangle1 = ((0.5 - x1 / (double)viewwidth) * FocalTangent * 90.0); double xangle2 = ((0.5 - x2 / (double)viewwidth) * FocalTangent * 90.0); double u1 = sky1pos + (ViewAngle.Degrees + xangle1) * sky1cyl / 360.0; double u2 = sky1pos + (ViewAngle.Degrees + xangle2) * sky1cyl / 360.0; double u = u1; double v = (y - CenterY) * skyiscale + skytexturemid * tex->Scale.Y; double uscale = (u2 - u1) / (x2 - x1); double vscale = 0.0; if (fixedlightlev >= 0) R_SetDSColorMapLight(key.ColorMap, 0, FIXEDLIGHT2SHADE(fixedlightlev)); else if (fixedcolormap) R_SetDSColorMapLight(fixedcolormap, 0, 0); else R_SetDSColorMapLight(key.ColorMap, 0, 0); ds_source = (const BYTE *)tex->GetPixelsBgra(); ds_source_mipmapped = false; ds_xbits = tex->WidthBits; ds_ybits = tex->HeightBits; ds_xfrac = (uint32_t)(u * (1 << (32 - ds_xbits))); ds_yfrac = (uint32_t)(v * (1 << (32 - ds_ybits))); ds_xstep = (uint32_t)(uscale * (1 << (32 - ds_xbits))); ds_ystep = (uint32_t)(vscale * (1 << (32 - ds_ybits))); ds_y = y; ds_x1 = x1; ds_x2 = x2; R_DrawSpan(); } } void RenderPlanes::Clear() { for (int i = 0; i < NumBuckets; i++) { std::unique_ptr plane = std::move(PlaneBuckets[i]); while (plane) { std::unique_ptr next = std::move(plane->Next); FreePlanes.push_back(std::move(plane)); plane = std::move(next); } } } void RenderPlanes::MarkCeilingPlane(const VisiblePlaneKey &key, const RenderClipBuffer &clip, const WallCoords &wallCoords) { VisibleSegmentsIterator it(clip, wallCoords.ScreenX1, wallCoords.ScreenX2); while (it.Step()) { VisiblePlane *plane = GetPlaneWithUnsetRange(key, it.X1, it.X2); for (short x = it.X1; x < it.X2; x++) { short walltop = MAX(wallCoords.Y1(x), clip.Top[x]); short top = clip.Top[x]; short bottom = MIN(walltop, clip.Bottom[x]); if (top < bottom) { plane->Top[x] = top; plane->Bottom[x] = bottom; } } } } void RenderPlanes::MarkFloorPlane(const VisiblePlaneKey &key, const RenderClipBuffer &clip, const WallCoords &wallCoords) { VisibleSegmentsIterator it(clip, wallCoords.ScreenX1, wallCoords.ScreenX2); while (it.Step()) { VisiblePlane *plane = GetPlaneWithUnsetRange(key, it.X1, it.X2); for (short x = it.X1; x < it.X2; x++) { short wallbottom = MIN(wallCoords.Y2(x), clip.Bottom[x]); short top = MAX(wallbottom, clip.Top[x]); short bottom = clip.Bottom[x]; if (top < bottom) { plane->Top[x] = top; plane->Bottom[x] = bottom; } } } } VisiblePlane *RenderPlanes::GetPlaneWithUnsetRange(const VisiblePlaneKey &key, int start, int stop) { VisiblePlane *plane = GetPlane(key); int intrl, intrh; int unionl, unionh; if (start < plane->Left) { intrl = plane->Left; unionl = start; } else { unionl = plane->Left; intrl = start; } if (stop > plane->Right) { intrh = plane->Right; unionh = stop; } else { unionh = plane->Right; intrh = stop; } // Verify that the entire range has unset values int x = intrl; while (x < intrh && plane->Top[x] == VisiblePlane::UnsetValue) x++; if (x >= intrh) // They do. Use the current plane { plane->Left = unionl; plane->Right = unionh; return plane; } else // Create new plane and make sure it is found first { auto &bucket = PlaneBuckets[Hash(key)]; std::unique_ptr newPlane = AllocPlane(key); newPlane->Left = start; newPlane->Right = stop; newPlane->Next = std::move(bucket); bucket = std::move(newPlane); return bucket.get(); } } VisiblePlane *RenderPlanes::GetPlane(const VisiblePlaneKey &key) { auto &bucket = PlaneBuckets[Hash(key)]; VisiblePlane *plane = bucket.get(); while (plane != nullptr) { if (plane->Key == key) return plane; plane = plane->Next.get(); } std::unique_ptr new_plane = AllocPlane(key); new_plane->Next = std::move(bucket); bucket = std::move(new_plane); return bucket.get(); } std::unique_ptr RenderPlanes::AllocPlane(const VisiblePlaneKey &key) { if (!FreePlanes.empty()) { std::unique_ptr plane = std::move(FreePlanes.back()); FreePlanes.pop_back(); plane->Clear(key); return std::move(plane); } else { return std::make_unique(key); } } ///////////////////////////////////////////////////////////////////////////// void RenderWall::Render(const RenderClipBuffer &clip) { FTexture *tex = GetTexture(); if (!tex) return; int texWidth = tex->GetWidth(); int texHeight = tex->GetHeight(); WallTextureCoords texcoords(tex, Line, Texpart, TopZ, BottomZ, UnpeggedCeil); VisibleSegmentsIterator it(clip, Coords.ScreenX1, Coords.ScreenX2); while (it.Step()) { for (short x = it.X1; x < it.X2; x++) { short y1 = MAX(Coords.Y1(x), clip.Top[x]); short y2 = MIN(Coords.Y2(x), clip.Bottom[x]); if (y1 >= y2) continue; double u = Coords.VaryingX(x, texcoords.u1, texcoords.u2); double v1 = Coords.VaryingY(x, y1, texcoords.v1, texcoords.v2); double v2 = Coords.VaryingY(x, y2, texcoords.v1, texcoords.v2); R_SetColorMapLight(Colormap, GetLight(x), GetShade()); dc_source = (const BYTE *)tex->GetColumnBgra((int)(u * texWidth), nullptr); dc_source2 = nullptr; dc_textureheight = texHeight; dc_texturefrac = (uint32_t)(v1 * 0xffffffff); dc_iscale = (uint32_t)((v2 - v1) / (y2 - y1) * 0xffffffff); dc_dest = dc_destorg + (ylookup[y1] + x) * 4; dc_count = y2 - y1; dovline1(); } } } void RenderWall::RenderMasked(short x1, short x2, const short *clipTop, const short *clipBottom) { FTexture *tex = GetTexture(); if (!tex) return; int texWidth = tex->GetWidth(); int texHeight = tex->GetHeight(); WallTextureCoords texcoords(tex, Line, Texpart, TopZ, BottomZ, UnpeggedCeil); for (short x = x1; x < x2; x++) { short y1 = MAX(Coords.Y1(x), clipTop[x - x1]); short y2 = MIN(Coords.Y2(x), clipBottom[x - x1]); if (y1 >= y2) continue; double u = Coords.VaryingX(x, texcoords.u1, texcoords.u2); double v1 = Coords.VaryingY(x, y1, texcoords.v1, texcoords.v2); double v2 = Coords.VaryingY(x, y2, texcoords.v1, texcoords.v2); R_SetColorMapLight(Colormap, GetLight(x), GetShade()); dc_source = (const BYTE *)tex->GetColumnBgra((int)(u * texWidth), nullptr); dc_source2 = nullptr; dc_textureheight = texHeight; dc_texturefrac = (uint32_t)(v1 * 0xffffffff); dc_iscale = (uint32_t)((v2 - v1) / (y2 - y1) * 0xffffffff); dc_dest = dc_destorg + (ylookup[y1] + x) * 4; dc_count = y2 - y1; domvline1(); } } FTexture *RenderWall::GetTexture() { FTexture *tex = TexMan(Line->sidedef->GetTexture(Texpart), true); if (tex == nullptr || tex->UseType == FTexture::TEX_Null) return nullptr; else return tex; } int RenderWall::GetShade() { if (fixedlightlev >= 0 || fixedcolormap) { return 0; } else { bool foggy = false; int actualextralight = foggy ? 0 : extralight << 4; int shade = LIGHT2SHADE(Line->sidedef->GetLightLevel(foggy, Line->frontsector->lightlevel) + actualextralight); return shade; } } float RenderWall::GetLight(short x) { if (fixedlightlev >= 0 || fixedcolormap) return 0.0f; else return (float)(r_WallVisibility / Coords.Z(x)); } ///////////////////////////////////////////////////////////////////////////// VisibleSprite::VisibleSprite(AActor *actor, const DVector3 &eyePos) : Actor(actor), EyePos(eyePos) { } void VisibleSprite::Render(RenderClipBuffer *clip) { //if (MirrorFlags & RF_XFLIP) // tx = -tx; bool flipTextureX = false; FTexture *tex = GetSpriteTexture(Actor, flipTextureX); DVector2 spriteScale = Actor->Scale; const double thingxscalemul = spriteScale.X / tex->Scale.X; double xscale = CenterX / EyePos.Z; double yscale = spriteScale.Y / tex->Scale.Y;// spriteScale.Y / tex->Scale.Y * InvZtoScale / EyePos.Z; double tx; if (flipTextureX) { tx = EyePos.X - (tex->GetWidth() - tex->LeftOffset - 1) * thingxscalemul; } else { tx = EyePos.X - tex->LeftOffset * thingxscalemul; } double texturemid = tex->TopOffset + (EyePos.Y - Actor->Floorclip) / yscale; double y = CenterY - texturemid * (InvZtoScale * yscale / EyePos.Z); int x1 = centerx + xs_RoundToInt(tx * xscale); int x2 = centerx + xs_RoundToInt((tx + tex->GetWidth() * thingxscalemul) * xscale); int y1 = xs_RoundToInt(y); int y2 = xs_RoundToInt(y + (InvZtoScale * yscale / EyePos.Z) * tex->GetHeight()); xscale = spriteScale.X * xscale / tex->Scale.X; int clipped_x1 = clamp(x1, 0, viewwidth - 1); int clipped_x2 = clamp(x2, 0, viewwidth - 1); int clipped_y1 = clamp(y1, 0, viewheight - 1); int clipped_y2 = clamp(y2, 0, viewheight - 1); if (clipped_x1 >= clipped_x2 || clipped_y1 >= clipped_y2) return; clip->SetupSpriteClip(clipped_x1, clipped_x2, EyePos, false); uint32_t texwidth = tex->GetWidth(); uint32_t texheight = tex->GetHeight(); visstyle_t visstyle = GetSpriteVisStyle(Actor, EyePos.Z); // Rumor has it that AlterWeaponSprite needs to be called with visstyle passed in somewhere around here.. R_SetColorMapLight(visstyle.BaseColormap, 0, visstyle.ColormapNum << FRACBITS); for (int x = clipped_x1; x < clipped_x2; x++) { short top = MAX(clipped_y1, clip->Top[x]); short bottom = MIN(clipped_y2, clip->Bottom[x]); if (top < bottom) { float u = (x - x1) / (float)(x2 - x1); float v = (top - y1) / (float)(y2 - y1); if (flipTextureX) u = 1.0f - u; u = u - floor(u); dc_source = (const BYTE *)tex->GetColumnBgra((int)(u * texwidth), nullptr); dc_source2 = nullptr; dc_textureheight = texheight; dc_texturefrac = (uint32_t)(v * 0xffffffff); dc_iscale = 0xffffffff / (y2 - y1); dc_dest = dc_destorg + (ylookup[top] + x) * 4; dc_count = bottom - top; domvline1(); } } } visstyle_t VisibleSprite::GetSpriteVisStyle(AActor *thing, double z) { visstyle_t visstyle; bool foggy = false; int actualextralight = foggy ? 0 : extralight << 4; int spriteshade = LIGHT2SHADE(thing->Sector->lightlevel + actualextralight); visstyle.RenderStyle = thing->RenderStyle; visstyle.Alpha = float(thing->Alpha); visstyle.ColormapNum = 0; // The software renderer cannot invert the source without inverting the overlay // too. That means if the source is inverted, we need to do the reverse of what // the invert overlay flag says to do. bool invertcolormap = (visstyle.RenderStyle.Flags & STYLEF_InvertOverlay) != 0; if (visstyle.RenderStyle.Flags & STYLEF_InvertSource) { invertcolormap = !invertcolormap; } FDynamicColormap *mybasecolormap = thing->Sector->ColorMap; // Sprites that are added to the scene must fade to black. if (visstyle.RenderStyle == LegacyRenderStyles[STYLE_Add] && mybasecolormap->Fade != 0) { mybasecolormap = GetSpecialLights(mybasecolormap->Color, 0, mybasecolormap->Desaturate); } if (visstyle.RenderStyle.Flags & STYLEF_FadeToBlack) { if (invertcolormap) { // Fade to white mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(255, 255, 255), mybasecolormap->Desaturate); invertcolormap = false; } else { // Fade to black mybasecolormap = GetSpecialLights(mybasecolormap->Color, MAKERGB(0, 0, 0), mybasecolormap->Desaturate); } } // get light level if (fixedcolormap != NULL) { // fixed map visstyle.BaseColormap = fixedcolormap; visstyle.ColormapNum = 0; } else { if (invertcolormap) { mybasecolormap = GetSpecialLights(mybasecolormap->Color, mybasecolormap->Fade.InverseColor(), mybasecolormap->Desaturate); } if (fixedlightlev >= 0) { visstyle.BaseColormap = mybasecolormap; visstyle.ColormapNum = fixedlightlev >> COLORMAPSHIFT; } else if (!foggy && ((thing->renderflags & RF_FULLBRIGHT) || (thing->flags5 & MF5_BRIGHT))) { // full bright visstyle.BaseColormap = mybasecolormap; visstyle.ColormapNum = 0; } else { // diminished light double minz = double((2048 * 4) / double(1 << 20)); visstyle.ColormapNum = GETPALOOKUP(r_SpriteVisibility / MAX(z, minz), spriteshade); visstyle.BaseColormap = mybasecolormap; } } return visstyle; } FTexture *VisibleSprite::GetSpriteTexture(AActor *thing, /*out*/ bool &flipX) { flipX = false; if (thing->picnum.isValid()) { FTexture *tex = TexMan(thing->picnum); if (tex->UseType == FTexture::TEX_Null) { return nullptr; } if (tex->Rotations != 0xFFFF) { // choose a different rotation based on player view spriteframe_t *sprframe = &SpriteFrames[tex->Rotations]; DVector3 pos = thing->InterpolatedPosition(r_TicFracF); pos.Z += thing->GetBobOffset(r_TicFracF); DAngle ang = (pos - ViewPos).Angle(); angle_t rot; if (sprframe->Texture[0] == sprframe->Texture[1]) { rot = (ang - thing->Angles.Yaw + 45.0 / 2 * 9).BAMs() >> 28; } else { rot = (ang - thing->Angles.Yaw + (45.0 / 2 * 9 - 180.0 / 16)).BAMs() >> 28; } flipX = (sprframe->Flip & (1 << rot)) != 0; tex = TexMan[sprframe->Texture[rot]]; // Do not animate the rotation } return tex; } else { // decide which texture to use for the sprite int spritenum = thing->sprite; if (spritenum >= (signed)sprites.Size() || spritenum < 0) return nullptr; spritedef_t *sprdef = &sprites[spritenum]; if (thing->frame >= sprdef->numframes) { // If there are no frames at all for this sprite, don't draw it. return nullptr; } else { //picnum = SpriteFrames[sprdef->spriteframes + thing->frame].Texture[0]; // choose a different rotation based on player view spriteframe_t *sprframe = &SpriteFrames[sprdef->spriteframes + thing->frame]; DVector3 pos = thing->InterpolatedPosition(r_TicFracF); pos.Z += thing->GetBobOffset(r_TicFracF); DAngle ang = (pos - ViewPos).Angle(); angle_t rot; if (sprframe->Texture[0] == sprframe->Texture[1]) { rot = (ang - thing->Angles.Yaw + 45.0 / 2 * 9).BAMs() >> 28; } else { rot = (ang - thing->Angles.Yaw + (45.0 / 2 * 9 - 180.0 / 16)).BAMs() >> 28; } flipX = (sprframe->Flip & (1 << rot)) != 0; return TexMan[sprframe->Texture[rot]]; // Do not animate the rotation } } } ///////////////////////////////////////////////////////////////////////////// void ScreenSprite::Render() { FSpecialColormap *special = nullptr; FColormapStyle colormapstyle; PalEntry overlay = 0; bool usecolormapstyle = false; if (visstyle.BaseColormap >= &SpecialColormaps[0] && visstyle.BaseColormap < &SpecialColormaps[SpecialColormaps.Size()]) { special = static_cast(visstyle.BaseColormap); } else if (Colormap->Color == PalEntry(255, 255, 255) && Colormap->Desaturate == 0) { overlay = Colormap->Fade; overlay.a = BYTE(visstyle.ColormapNum * 255 / NUMCOLORMAPS); } else { usecolormapstyle = true; colormapstyle.Color = Colormap->Color; colormapstyle.Fade = Colormap->Fade; colormapstyle.Desaturate = Colormap->Desaturate; colormapstyle.FadeLevel = visstyle.ColormapNum / float(NUMCOLORMAPS); } screen->DrawTexture(Pic, X1, Y1, DTA_DestWidthF, Width, DTA_DestHeightF, Height, DTA_Translation, Translation, DTA_FlipX, Flip, DTA_TopOffset, 0, DTA_LeftOffset, 0, DTA_ClipLeft, viewwindowx, DTA_ClipTop, viewwindowy, DTA_ClipRight, viewwindowx + viewwidth, DTA_ClipBottom, viewwindowy + viewheight, DTA_AlphaF, visstyle.Alpha, DTA_RenderStyle, visstyle.RenderStyle, DTA_FillColor, FillColor, DTA_SpecialColormap, special, DTA_ColorOverlay, overlay.d, DTA_ColormapStyle, usecolormapstyle ? &colormapstyle : NULL, TAG_DONE); }