9416d436fe
any access explicit. This reveals the places in the code where they are being accessed where they shouldn't and prevents accidental usage.
438 lines
14 KiB
C++
438 lines
14 KiB
C++
/*
|
|
** Handling drawing a plane (ceiling, floor)
|
|
** Copyright (c) 2016 Magnus Norddahl
|
|
**
|
|
** This software is provided 'as-is', without any express or implied
|
|
** warranty. In no event will the authors be held liable for any damages
|
|
** arising from the use of this software.
|
|
**
|
|
** Permission is granted to anyone to use this software for any purpose,
|
|
** including commercial applications, and to alter it and redistribute it
|
|
** freely, subject to the following restrictions:
|
|
**
|
|
** 1. The origin of this software must not be misrepresented; you must not
|
|
** claim that you wrote the original software. If you use this software
|
|
** in a product, an acknowledgment in the product documentation would be
|
|
** appreciated but is not required.
|
|
** 2. Altered source versions must be plainly marked as such, and must not be
|
|
** misrepresented as being the original software.
|
|
** 3. This notice may not be removed or altered from any source distribution.
|
|
**
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include "templates.h"
|
|
#include "doomdef.h"
|
|
#include "sbar.h"
|
|
#include "r_data/r_translate.h"
|
|
#include "r_poly_plane.h"
|
|
#include "r_poly_portal.h"
|
|
#include "r_poly.h"
|
|
#include "r_sky.h"
|
|
|
|
EXTERN_CVAR(Int, r_3dfloors)
|
|
|
|
void RenderPolyPlane::RenderPlanes(const TriMatrix &worldToClip, const Vec4f &clipPlane, subsector_t *sub, uint32_t subsectorDepth, uint32_t stencilValue, double skyCeilingHeight, double skyFloorHeight, std::vector<std::unique_ptr<PolyDrawSectorPortal>> §orPortals)
|
|
{
|
|
RenderPolyPlane plane;
|
|
|
|
if (r_3dfloors)
|
|
{
|
|
auto frontsector = sub->sector;
|
|
auto &ffloors = frontsector->e->XFloor.ffloors;
|
|
|
|
// 3D floor floors
|
|
for (int i = 0; i < (int)ffloors.Size(); i++)
|
|
{
|
|
F3DFloor *fakeFloor = ffloors[i];
|
|
if (!(fakeFloor->flags & FF_EXISTS)) continue;
|
|
if (!fakeFloor->model) continue;
|
|
if (fakeFloor->bottom.plane->isSlope()) continue;
|
|
//if (!(fakeFloor->flags & FF_NOSHADE) || (fakeFloor->flags & (FF_RENDERPLANES | FF_RENDERSIDES)))
|
|
// R_3D_AddHeight(fakeFloor->top.plane, frontsector);
|
|
if (!(fakeFloor->flags & FF_RENDERPLANES)) continue;
|
|
if (fakeFloor->alpha == 0) continue;
|
|
if (fakeFloor->flags & FF_THISINSIDE && fakeFloor->flags & FF_INVERTSECTOR) continue;
|
|
//fakeFloor->alpha
|
|
|
|
double fakeHeight = fakeFloor->top.plane->ZatPoint(frontsector->centerspot);
|
|
if (fakeHeight < ViewPos.Z && fakeHeight > frontsector->floorplane.ZatPoint(frontsector->centerspot))
|
|
{
|
|
plane.Render3DFloor(worldToClip, clipPlane, sub, subsectorDepth, stencilValue, false, fakeFloor);
|
|
}
|
|
}
|
|
|
|
// 3D floor ceilings
|
|
for (int i = 0; i < (int)ffloors.Size(); i++)
|
|
{
|
|
F3DFloor *fakeFloor = ffloors[i];
|
|
if (!(fakeFloor->flags & FF_EXISTS)) continue;
|
|
if (!fakeFloor->model) continue;
|
|
if (fakeFloor->top.plane->isSlope()) continue;
|
|
//if (!(fakeFloor->flags & FF_NOSHADE) || (fakeFloor->flags & (FF_RENDERPLANES | FF_RENDERSIDES)))
|
|
// R_3D_AddHeight(fakeFloor->bottom.plane, frontsector);
|
|
if (!(fakeFloor->flags & FF_RENDERPLANES)) continue;
|
|
if (fakeFloor->alpha == 0) continue;
|
|
if (!(fakeFloor->flags & FF_THISINSIDE) && (fakeFloor->flags & (FF_SWIMMABLE | FF_INVERTSECTOR)) == (FF_SWIMMABLE | FF_INVERTSECTOR)) continue;
|
|
//fakeFloor->alpha
|
|
|
|
double fakeHeight = fakeFloor->bottom.plane->ZatPoint(frontsector->centerspot);
|
|
if (fakeHeight > ViewPos.Z && fakeHeight < frontsector->ceilingplane.ZatPoint(frontsector->centerspot))
|
|
{
|
|
plane.Render3DFloor(worldToClip, clipPlane, sub, subsectorDepth, stencilValue, true, fakeFloor);
|
|
}
|
|
}
|
|
}
|
|
|
|
plane.Render(worldToClip, clipPlane, sub, subsectorDepth, stencilValue, true, skyCeilingHeight, sectorPortals);
|
|
plane.Render(worldToClip, clipPlane, sub, subsectorDepth, stencilValue, false, skyFloorHeight, sectorPortals);
|
|
}
|
|
|
|
void RenderPolyPlane::Render3DFloor(const TriMatrix &worldToClip, const Vec4f &clipPlane, subsector_t *sub, uint32_t subsectorDepth, uint32_t stencilValue, bool ceiling, F3DFloor *fakeFloor)
|
|
{
|
|
FTextureID picnum = ceiling ? *fakeFloor->bottom.texture : *fakeFloor->top.texture;
|
|
FTexture *tex = TexMan(picnum);
|
|
if (tex->UseType == FTexture::TEX_Null)
|
|
return;
|
|
|
|
int lightlevel = 255;
|
|
if (swrenderer::fixedlightlev < 0 && sub->sector->e->XFloor.lightlist.Size())
|
|
{
|
|
lightlist_t *light = P_GetPlaneLight(sub->sector, &sub->sector->ceilingplane, false);
|
|
swrenderer::basecolormap = light->extra_colormap;
|
|
lightlevel = *light->p_lightlevel;
|
|
}
|
|
|
|
UVTransform xform(ceiling ? fakeFloor->top.model->planes[sector_t::ceiling].xform : fakeFloor->top.model->planes[sector_t::floor].xform, tex);
|
|
|
|
PolyDrawArgs args;
|
|
args.uniforms.light = (uint32_t)(lightlevel / 255.0f * 256.0f);
|
|
if (swrenderer::fixedlightlev >= 0 || swrenderer::fixedcolormap)
|
|
args.uniforms.light = 256;
|
|
args.uniforms.flags = 0;
|
|
args.uniforms.subsectorDepth = subsectorDepth;
|
|
|
|
TriVertex *vertices = PolyVertexBuffer::GetVertices(sub->numlines);
|
|
if (!vertices)
|
|
return;
|
|
|
|
if (ceiling)
|
|
{
|
|
for (uint32_t i = 0; i < sub->numlines; i++)
|
|
{
|
|
seg_t *line = &sub->firstline[i];
|
|
vertices[sub->numlines - 1 - i] = PlaneVertex(line->v1, fakeFloor->bottom.plane->ZatPoint(line->v1), xform);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint32_t i = 0; i < sub->numlines; i++)
|
|
{
|
|
seg_t *line = &sub->firstline[i];
|
|
vertices[i] = PlaneVertex(line->v1, fakeFloor->top.plane->ZatPoint(line->v1), xform);
|
|
}
|
|
}
|
|
|
|
args.objectToClip = &worldToClip;
|
|
args.vinput = vertices;
|
|
args.vcount = sub->numlines;
|
|
args.mode = TriangleDrawMode::Fan;
|
|
args.ccw = true;
|
|
args.stenciltestvalue = stencilValue;
|
|
args.stencilwritevalue = stencilValue + 1;
|
|
args.SetTexture(tex);
|
|
args.SetColormap(sub->sector->ColorMap);
|
|
args.SetClipPlane(clipPlane.x, clipPlane.y, clipPlane.z, clipPlane.w);
|
|
PolyTriangleDrawer::draw(args, TriDrawVariant::DrawNormal, TriBlendMode::Copy);
|
|
PolyTriangleDrawer::draw(args, TriDrawVariant::Stencil, TriBlendMode::Copy);
|
|
}
|
|
|
|
void RenderPolyPlane::Render(const TriMatrix &worldToClip, const Vec4f &clipPlane, subsector_t *sub, uint32_t subsectorDepth, uint32_t stencilValue, bool ceiling, double skyHeight, std::vector<std::unique_ptr<PolyDrawSectorPortal>> §orPortals)
|
|
{
|
|
FSectorPortal *portal = sub->sector->ValidatePortal(ceiling ? sector_t::ceiling : sector_t::floor);
|
|
PolyDrawSectorPortal *polyportal = nullptr;
|
|
if (portal && (portal->mFlags & PORTSF_INSKYBOX) == PORTSF_INSKYBOX) // Do not recurse into portals we already recursed into
|
|
portal = nullptr;
|
|
if (portal)
|
|
{
|
|
for (auto &p : sectorPortals)
|
|
{
|
|
if (p->Portal == portal) // To do: what other criterias do we need to check for?
|
|
{
|
|
polyportal = p.get();
|
|
break;
|
|
}
|
|
}
|
|
if (!polyportal)
|
|
{
|
|
sectorPortals.push_back(std::make_unique<PolyDrawSectorPortal>(portal, ceiling));
|
|
polyportal = sectorPortals.back().get();
|
|
}
|
|
}
|
|
|
|
sector_t *fakesector = sub->sector->heightsec;
|
|
if (fakesector && (fakesector == sub->sector || (fakesector->MoreFlags & SECF_IGNOREHEIGHTSEC) == SECF_IGNOREHEIGHTSEC))
|
|
fakesector = nullptr;
|
|
|
|
bool fakeflooronly = fakesector && (fakesector->MoreFlags & SECF_FAKEFLOORONLY) == SECF_FAKEFLOORONLY;
|
|
|
|
FTextureID picnum;
|
|
bool ccw;
|
|
sector_t *frontsector;
|
|
if (fakesector)
|
|
{
|
|
// Floor and ceiling texture needs to be swapped sometimes? Why?? :(
|
|
|
|
if (ViewPos.Z < fakesector->floorplane.Zat0()) // In water
|
|
{
|
|
if (ceiling)
|
|
{
|
|
picnum = fakesector->GetTexture(sector_t::ceiling);
|
|
ceiling = false;
|
|
frontsector = fakesector;
|
|
ccw = false;
|
|
}
|
|
else
|
|
{
|
|
picnum = fakesector->GetTexture(sector_t::floor);
|
|
frontsector = sub->sector;
|
|
ccw = true;
|
|
}
|
|
}
|
|
else if (ViewPos.Z >= fakesector->ceilingplane.Zat0() && !fakeflooronly) // In ceiling water
|
|
{
|
|
if (ceiling)
|
|
{
|
|
picnum = fakesector->GetTexture(sector_t::ceiling);
|
|
frontsector = sub->sector;
|
|
ccw = true;
|
|
}
|
|
else
|
|
{
|
|
picnum = fakesector->GetTexture(sector_t::floor);
|
|
frontsector = fakesector;
|
|
ccw = false;
|
|
ceiling = true;
|
|
}
|
|
}
|
|
else if (!ceiling) // Water surface
|
|
{
|
|
picnum = fakesector->GetTexture(sector_t::ceiling);
|
|
frontsector = fakesector;
|
|
ccw = true;
|
|
}
|
|
else if (!fakeflooronly) // Ceiling water surface
|
|
{
|
|
picnum = fakesector->GetTexture(sector_t::floor);
|
|
frontsector = fakesector;
|
|
ccw = true;
|
|
}
|
|
else // Upper ceiling
|
|
{
|
|
picnum = sub->sector->GetTexture(sector_t::ceiling);
|
|
ccw = true;
|
|
frontsector = sub->sector;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
picnum = sub->sector->GetTexture(ceiling ? sector_t::ceiling : sector_t::floor);
|
|
ccw = true;
|
|
frontsector = sub->sector;
|
|
}
|
|
|
|
FTexture *tex = TexMan(picnum);
|
|
if (tex->UseType == FTexture::TEX_Null)
|
|
return;
|
|
|
|
bool isSky = picnum == skyflatnum;
|
|
|
|
UVTransform transform(ceiling ? frontsector->planes[sector_t::ceiling].xform : frontsector->planes[sector_t::floor].xform, tex);
|
|
|
|
PolyDrawArgs args;
|
|
args.uniforms.light = (uint32_t)(frontsector->lightlevel / 255.0f * 256.0f);
|
|
if (swrenderer::fixedlightlev >= 0 || swrenderer::fixedcolormap)
|
|
args.uniforms.light = 256;
|
|
args.uniforms.flags = 0;
|
|
args.uniforms.subsectorDepth = isSky ? RenderPolyPortal::SkySubsectorDepth : subsectorDepth;
|
|
|
|
TriVertex *vertices = PolyVertexBuffer::GetVertices(sub->numlines);
|
|
if (!vertices)
|
|
return;
|
|
|
|
if (ceiling)
|
|
{
|
|
for (uint32_t i = 0; i < sub->numlines; i++)
|
|
{
|
|
seg_t *line = &sub->firstline[i];
|
|
vertices[sub->numlines - 1 - i] = PlaneVertex(line->v1, isSky ? skyHeight : frontsector->ceilingplane.ZatPoint(line->v1), transform);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint32_t i = 0; i < sub->numlines; i++)
|
|
{
|
|
seg_t *line = &sub->firstline[i];
|
|
vertices[i] = PlaneVertex(line->v1, isSky ? skyHeight : frontsector->floorplane.ZatPoint(line->v1), transform);
|
|
}
|
|
}
|
|
|
|
args.objectToClip = &worldToClip;
|
|
args.vinput = vertices;
|
|
args.vcount = sub->numlines;
|
|
args.mode = TriangleDrawMode::Fan;
|
|
args.ccw = ccw;
|
|
args.stenciltestvalue = stencilValue;
|
|
args.stencilwritevalue = stencilValue + 1;
|
|
args.SetColormap(frontsector->ColorMap);
|
|
args.SetClipPlane(clipPlane.x, clipPlane.y, clipPlane.z, clipPlane.w);
|
|
|
|
if (!isSky)
|
|
{
|
|
if (!portal)
|
|
{
|
|
args.SetTexture(tex);
|
|
PolyTriangleDrawer::draw(args, TriDrawVariant::DrawNormal, TriBlendMode::Copy);
|
|
PolyTriangleDrawer::draw(args, TriDrawVariant::Stencil, TriBlendMode::Copy);
|
|
}
|
|
else
|
|
{
|
|
args.stencilwritevalue = polyportal->StencilValue;
|
|
PolyTriangleDrawer::draw(args, TriDrawVariant::Stencil, TriBlendMode::Copy);
|
|
polyportal->Shape.push_back({ args.vinput, args.vcount, args.ccw, subsectorDepth });
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (portal)
|
|
{
|
|
args.stencilwritevalue = polyportal->StencilValue;
|
|
polyportal->Shape.push_back({ args.vinput, args.vcount, args.ccw, subsectorDepth });
|
|
}
|
|
else
|
|
{
|
|
args.stencilwritevalue = 255;
|
|
}
|
|
|
|
PolyTriangleDrawer::draw(args, TriDrawVariant::Stencil, TriBlendMode::Copy);
|
|
|
|
for (uint32_t i = 0; i < sub->numlines; i++)
|
|
{
|
|
TriVertex *wallvert = PolyVertexBuffer::GetVertices(4);
|
|
if (!wallvert)
|
|
return;
|
|
|
|
seg_t *line = &sub->firstline[i];
|
|
|
|
double skyBottomz1 = frontsector->ceilingplane.ZatPoint(line->v1);
|
|
double skyBottomz2 = frontsector->ceilingplane.ZatPoint(line->v2);
|
|
if (line->backsector)
|
|
{
|
|
sector_t *backsector = (line->backsector != line->frontsector) ? line->backsector : line->frontsector;
|
|
|
|
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);
|
|
|
|
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 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 closedSector = backceilz1 == backfloorz1 && backceilz2 == backfloorz2;
|
|
if (ceiling && bothSkyCeiling && closedSector)
|
|
{
|
|
skyBottomz1 = middlefloorz1;
|
|
skyBottomz2 = middlefloorz2;
|
|
}
|
|
else if (bothSkyCeiling)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (ceiling)
|
|
{
|
|
wallvert[0] = PlaneVertex(line->v1, skyHeight, transform);
|
|
wallvert[1] = PlaneVertex(line->v2, skyHeight, transform);
|
|
wallvert[2] = PlaneVertex(line->v2, skyBottomz2, transform);
|
|
wallvert[3] = PlaneVertex(line->v1, skyBottomz1, transform);
|
|
}
|
|
else
|
|
{
|
|
wallvert[0] = PlaneVertex(line->v1, frontsector->floorplane.ZatPoint(line->v1), transform);
|
|
wallvert[1] = PlaneVertex(line->v2, frontsector->floorplane.ZatPoint(line->v2), transform);
|
|
wallvert[2] = PlaneVertex(line->v2, skyHeight, transform);
|
|
wallvert[3] = PlaneVertex(line->v1, skyHeight, transform);
|
|
}
|
|
|
|
args.vinput = wallvert;
|
|
args.vcount = 4;
|
|
PolyTriangleDrawer::draw(args, TriDrawVariant::Stencil, TriBlendMode::Copy);
|
|
|
|
if (portal)
|
|
polyportal->Shape.push_back({ args.vinput, args.vcount, args.ccw, subsectorDepth });
|
|
}
|
|
}
|
|
}
|
|
|
|
TriVertex RenderPolyPlane::PlaneVertex(vertex_t *v1, double height, const UVTransform &transform)
|
|
{
|
|
TriVertex v;
|
|
v.x = (float)v1->fPos().X;
|
|
v.y = (float)v1->fPos().Y;
|
|
v.z = (float)height;
|
|
v.w = 1.0f;
|
|
v.varying[0] = transform.GetU(v.x, v.y);
|
|
v.varying[1] = transform.GetV(v.x, v.y);
|
|
return v;
|
|
}
|
|
|
|
RenderPolyPlane::UVTransform::UVTransform(const FTransform &transform, FTexture *tex)
|
|
{
|
|
if (tex)
|
|
{
|
|
xscale = (float)(transform.xScale * tex->Scale.X / tex->GetWidth());
|
|
yscale = (float)(transform.yScale * tex->Scale.Y / tex->GetHeight());
|
|
|
|
double planeang = (transform.Angle + transform.baseAngle).Radians();
|
|
cosine = (float)cos(planeang);
|
|
sine = (float)sin(planeang);
|
|
|
|
xOffs = (float)transform.xOffs;
|
|
yOffs = (float)transform.yOffs;
|
|
}
|
|
else
|
|
{
|
|
xscale = 1.0f / 64.0f;
|
|
yscale = 1.0f / 64.0f;
|
|
cosine = 1.0f;
|
|
sine = 0.0f;
|
|
xOffs = 0.0f;
|
|
yOffs = 0.0f;
|
|
}
|
|
}
|
|
|
|
float RenderPolyPlane::UVTransform::GetU(float x, float y) const
|
|
{
|
|
return (xOffs + x * cosine - y * sine) * xscale;
|
|
}
|
|
|
|
float RenderPolyPlane::UVTransform::GetV(float x, float y) const
|
|
{
|
|
return (yOffs - x * sine - y * cosine) * yscale;
|
|
}
|