zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-13 07:57:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

Adjust class naming to closer match the GZDoom renderer and split portal rendering part to its own file

Browse source
This commit is contained in:
Magnus Norddahl 2016-12-03 14:58:56 +01:00
parent dbacb75617
commit e09c7d239f
10 changed files with 470 additions and 414 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/CMakeLists.txt
View file

@ -1030,6 +1030,7 @@ set( NOT_COMPILED_SOURCE_FILES
set( FASTMATH_PCH_SOURCES set( FASTMATH_PCH_SOURCES
r_swrenderer.cpp r_swrenderer.cpp
r_poly.cpp r_poly.cpp
r_poly_scene.cpp
r_poly_portal.cpp r_poly_portal.cpp
r_poly_cull.cpp r_poly_cull.cpp
r_poly_decal.cpp r_poly_decal.cpp

16
src/r_poly.cpp
View file

@ -37,13 +37,13 @@ extern bool r_showviewer;
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
RenderPolyScene *RenderPolyScene::Instance() PolyRenderer *PolyRenderer::Instance()
{ {
static RenderPolyScene scene; static PolyRenderer scene;
return &scene; return &scene;
} }
void RenderPolyScene::RenderViewToCanvas(AActor *actor, DCanvas *canvas, int x, int y, int width, int height, bool dontmaplines) void PolyRenderer::RenderViewToCanvas(AActor *actor, DCanvas *canvas, int x, int y, int width, int height, bool dontmaplines)
{ {
const bool savedviewactive = viewactive; const bool savedviewactive = viewactive;
const bool savedoutputformat = swrenderer::r_swtruecolor; const bool savedoutputformat = swrenderer::r_swtruecolor;
@ -70,7 +70,7 @@ void RenderPolyScene::RenderViewToCanvas(AActor *actor, DCanvas *canvas, int x,
swrenderer::r_swtruecolor = savedoutputformat; swrenderer::r_swtruecolor = savedoutputformat;
} }
void RenderPolyScene::RenderActorView(AActor *actor, bool dontmaplines) void PolyRenderer::RenderActorView(AActor *actor, bool dontmaplines)
{ {
NetUpdate(); NetUpdate();
@ -106,12 +106,12 @@ void RenderPolyScene::RenderActorView(AActor *actor, bool dontmaplines)
NetUpdate(); NetUpdate();
} }
void RenderPolyScene::RenderRemainingPlayerSprites() void PolyRenderer::RenderRemainingPlayerSprites()
{ {
PlayerSprites.RenderRemainingSprites(); PlayerSprites.RenderRemainingSprites();
} }
void RenderPolyScene::ClearBuffers() void PolyRenderer::ClearBuffers()
{ {
PolyVertexBuffer::Clear(); PolyVertexBuffer::Clear();
PolyStencilBuffer::Instance()->Clear(RenderTarget->GetWidth(), RenderTarget->GetHeight(), 0); PolyStencilBuffer::Instance()->Clear(RenderTarget->GetWidth(), RenderTarget->GetHeight(), 0);
@ -119,7 +119,7 @@ void RenderPolyScene::ClearBuffers()
NextStencilValue = 0; NextStencilValue = 0;
} }
void RenderPolyScene::SetSceneViewport() void PolyRenderer::SetSceneViewport()
{ {
if (RenderTarget == screen) // Rendering to screen if (RenderTarget == screen) // Rendering to screen
{ {
@ -138,7 +138,7 @@ void RenderPolyScene::SetSceneViewport()
} }
} }
void RenderPolyScene::SetupPerspectiveMatrix() void PolyRenderer::SetupPerspectiveMatrix()
{ {
static bool bDidSetup = false; static bool bDidSetup = false;

7
src/r_poly.h
View file

@ -36,15 +36,14 @@
class AActor; class AActor;
class DCanvas; class DCanvas;
// Renders a scene class PolyRenderer
class RenderPolyScene
{ {
public: public:
void RenderViewToCanvas(AActor *actor, DCanvas *canvas, int x, int y, int width, int height, bool dontmaplines); void RenderViewToCanvas(AActor *actor, DCanvas *canvas, int x, int y, int width, int height, bool dontmaplines);
void RenderActorView(AActor *actor, bool dontmaplines); void RenderActorView(AActor *actor, bool dontmaplines);
void RenderRemainingPlayerSprites(); void RenderRemainingPlayerSprites();
static RenderPolyScene *Instance(); static PolyRenderer *Instance();
uint32_t GetNextStencilValue() { uint32_t value = NextStencilValue; NextStencilValue += 2; return value; } uint32_t GetNextStencilValue() { uint32_t value = NextStencilValue; NextStencilValue += 2; return value; }
@ -54,7 +53,7 @@ private:
void SetupPerspectiveMatrix(); void SetupPerspectiveMatrix();
TriMatrix WorldToClip; TriMatrix WorldToClip;
RenderPolyPortal MainPortal; RenderPolyScene MainPortal;
PolySkyDome Skydome; PolySkyDome Skydome;
RenderPolyPlayerSprites PlayerSprites; RenderPolyPlayerSprites PlayerSprites;
uint32_t NextStencilValue = 0; uint32_t NextStencilValue = 0;

2
src/r_poly_plane.cpp
View file

@ -254,7 +254,7 @@ void RenderPolyPlane::Render(const TriMatrix &worldToClip, const Vec4f &clipPlan
if (swrenderer::fixedlightlev >= 0 || swrenderer::fixedcolormap) if (swrenderer::fixedlightlev >= 0 || swrenderer::fixedcolormap)
args.uniforms.light = 256; args.uniforms.light = 256;
args.uniforms.flags = 0; args.uniforms.flags = 0;
args.uniforms.subsectorDepth = isSky ? RenderPolyPortal::SkySubsectorDepth : subsectorDepth; args.uniforms.subsectorDepth = isSky ? RenderPolyScene::SkySubsectorDepth : subsectorDepth;
TriVertex *vertices = PolyVertexBuffer::GetVertices(sub->numlines); TriVertex *vertices = PolyVertexBuffer::GetVertices(sub->numlines);
if (!vertices) if (!vertices)

320
src/r_poly_portal.cpp
View file

@ -30,323 +30,13 @@
#include "r_poly.h" #include "r_poly.h"
#include "gl/data/gl_data.h" #include "gl/data/gl_data.h"
CVAR(Bool, r_debug_cull, 0, 0)
EXTERN_CVAR(Int, r_portal_recursions)
extern bool r_showviewer; extern bool r_showviewer;
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
RenderPolyPortal::RenderPolyPortal()
{
}
RenderPolyPortal::~RenderPolyPortal()
{
}
void RenderPolyPortal::SetViewpoint(const TriMatrix &worldToClip, const Vec4f &portalPlane, uint32_t stencilValue)
{
WorldToClip = worldToClip;
StencilValue = stencilValue;
PortalPlane = portalPlane;
}
void RenderPolyPortal::Render(int portalDepth)
{
ClearBuffers();
Cull.CullScene(WorldToClip, PortalPlane);
RenderSectors();
RenderPortals(portalDepth);
}
void RenderPolyPortal::ClearBuffers()
{
SeenSectors.clear();
SubsectorDepths.clear();
TranslucentObjects.clear();
SectorPortals.clear();
LinePortals.clear();
NextSubsectorDepth = 0;
}
void RenderPolyPortal::RenderSectors()
{
if (r_debug_cull)
{
for (auto it = Cull.PvsSectors.rbegin(); it != Cull.PvsSectors.rend(); ++it)
RenderSubsector(*it);
}
else
{
for (auto it = Cull.PvsSectors.begin(); it != Cull.PvsSectors.end(); ++it)
RenderSubsector(*it);
}
}
void RenderPolyPortal::RenderSubsector(subsector_t *sub)
{
sector_t *frontsector = sub->sector;
frontsector->MoreFlags |= SECF_DRAWN;
uint32_t subsectorDepth = NextSubsectorDepth++;
if (sub->sector->CenterFloor() != sub->sector->CenterCeiling())
{
RenderPolyPlane::RenderPlanes(WorldToClip, PortalPlane, sub, subsectorDepth, StencilValue, Cull.MaxCeilingHeight, Cull.MinFloorHeight, SectorPortals);
}
for (uint32_t i = 0; i < sub->numlines; i++)
{
seg_t *line = &sub->firstline[i];
if (line->sidedef == nullptr || !(line->sidedef->Flags & WALLF_POLYOBJ))
{
RenderLine(sub, line, frontsector, subsectorDepth);
}
}
bool mainBSP = ((unsigned int)(sub - subsectors) < (unsigned int)numsubsectors);
if (mainBSP)
{
int subsectorIndex = (int)(sub - subsectors);
for (int i = ParticlesInSubsec[subsectorIndex]; i != NO_PARTICLE; i = Particles[i].snext)
{
particle_t *particle = Particles + i;
TranslucentObjects.push_back({ particle, sub, subsectorDepth });
}
}
SeenSectors.insert(sub->sector);
SubsectorDepths[sub] = subsectorDepth;
}
void RenderPolyPortal::RenderSprite(AActor *thing, double sortDistance, const DVector2 &left, const DVector2 &right)
{
if (numnodes == 0)
RenderSprite(thing, sortDistance, left, right, 0.0, 1.0, subsectors);
else
RenderSprite(thing, sortDistance, left, right, 0.0, 1.0, nodes + numnodes - 1); // The head node is the last node output.
}
void RenderPolyPortal::RenderSprite(AActor *thing, double sortDistance, DVector2 left, DVector2 right, double t1, double t2, void *node)
{
while (!((size_t)node & 1)) // Keep going until found a subsector
{
node_t *bsp = (node_t *)node;
DVector2 planePos(FIXED2DBL(bsp->x), FIXED2DBL(bsp->y));
DVector2 planeNormal = DVector2(FIXED2DBL(-bsp->dy), FIXED2DBL(bsp->dx));
double planeD = planeNormal | planePos;
int sideLeft = (left | planeNormal) > planeD;
int sideRight = (right | planeNormal) > planeD;
if (sideLeft != sideRight)
{
double dotLeft = planeNormal | left;
double dotRight = planeNormal | right;
double t = (planeD - dotLeft) / (dotRight - dotLeft);
DVector2 mid = left * (1.0 - t) + right * t;
double tmid = t1 * (1.0 - t) + t2 * t;
RenderSprite(thing, sortDistance, mid, right, tmid, t2, bsp->children[sideRight]);
right = mid;
t2 = tmid;
}
node = bsp->children[sideLeft];
}
subsector_t *sub = (subsector_t *)((BYTE *)node - 1);
auto it = SubsectorDepths.find(sub);
if (it != SubsectorDepths.end())
TranslucentObjects.push_back({ thing, sub, it->second, sortDistance, (float)t1, (float)t2 });
}
void RenderPolyPortal::RenderLine(subsector_t *sub, seg_t *line, sector_t *frontsector, uint32_t subsectorDepth)
{
// 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;
// Cull wall if not visible
int sx1, sx2;
LineSegmentRange segmentRange = Cull.GetSegmentRangeForLine(line->v1->fX(), line->v1->fY(), line->v2->fX(), line->v2->fY(), sx1, sx2);
if (segmentRange == LineSegmentRange::NotVisible || (segmentRange == LineSegmentRange::HasSegment && Cull.IsSegmentCulled(sx1, sx2)))
return;
// Tell automap we saw this
if (!swrenderer::r_dontmaplines && line->linedef && segmentRange != LineSegmentRange::AlwaysVisible)
{
line->linedef->flags |= ML_MAPPED;
sub->flags |= SSECF_DRAWN;
}
// Render 3D floor sides
if (line->backsector && frontsector->e && line->backsector->e->XFloor.ffloors.Size())
{
for (unsigned int i = 0; i < line->backsector->e->XFloor.ffloors.Size(); i++)
{
F3DFloor *fakeFloor = line->backsector->e->XFloor.ffloors[i];
if (!(fakeFloor->flags & FF_EXISTS)) continue;
if (!(fakeFloor->flags & FF_RENDERPLANES)) continue;
if (!fakeFloor->model) continue;
RenderPolyWall::Render3DFloorLine(WorldToClip, PortalPlane, line, frontsector, subsectorDepth, StencilValue, fakeFloor, TranslucentObjects);
}
}
// Render wall, and update culling info if its an occlusion blocker
if (RenderPolyWall::RenderLine(WorldToClip, PortalPlane, line, frontsector, subsectorDepth, StencilValue, TranslucentObjects, LinePortals))
{
if (segmentRange == LineSegmentRange::HasSegment)
Cull.MarkSegmentCulled(sx1, sx2);
}
}
void RenderPolyPortal::RenderPortals(int portalDepth)
{
if (portalDepth < r_portal_recursions)
{
for (auto &portal : SectorPortals)
portal->Render(portalDepth + 1);
for (auto &portal : LinePortals)
portal->Render(portalDepth + 1);
}
else // Fill with black
{
PolyDrawArgs args;
args.objectToClip = &WorldToClip;
args.mode = TriangleDrawMode::Fan;
args.uniforms.color = 0;
args.uniforms.light = 256;
args.uniforms.flags = TriUniforms::fixed_light;
args.SetClipPlane(PortalPlane.x, PortalPlane.y, PortalPlane.z, PortalPlane.w);
for (auto &portal : SectorPortals)
{
args.stenciltestvalue = portal->StencilValue;
args.stencilwritevalue = portal->StencilValue + 1;
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::FillNormal, TriBlendMode::Copy);
}
}
for (auto &portal : LinePortals)
{
args.stenciltestvalue = portal->StencilValue;
args.stencilwritevalue = portal->StencilValue + 1;
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::FillNormal, TriBlendMode::Copy);
}
}
}
}
void RenderPolyPortal::RenderTranslucent(int portalDepth)
{
if (portalDepth < r_portal_recursions)
{
for (auto it = SectorPortals.rbegin(); it != SectorPortals.rend(); ++it)
{
auto &portal = *it;
portal->RenderTranslucent(portalDepth + 1);
PolyDrawArgs args;
args.objectToClip = &WorldToClip;
args.mode = TriangleDrawMode::Fan;
args.stenciltestvalue = portal->StencilValue + 1;
args.stencilwritevalue = StencilValue;
args.SetClipPlane(PortalPlane.x, PortalPlane.y, PortalPlane.z, PortalPlane.w);
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::StencilClose, TriBlendMode::Copy);
}
}
for (auto it = LinePortals.rbegin(); it != LinePortals.rend(); ++it)
{
auto &portal = *it;
portal->RenderTranslucent(portalDepth + 1);
PolyDrawArgs args;
args.objectToClip = &WorldToClip;
args.mode = TriangleDrawMode::Fan;
args.stenciltestvalue = portal->StencilValue + 1;
args.stencilwritevalue = StencilValue;
args.SetClipPlane(PortalPlane.x, PortalPlane.y, PortalPlane.z, PortalPlane.w);
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::StencilClose, TriBlendMode::Copy);
}
}
}
for (sector_t *sector : SeenSectors)
{
for (AActor *thing = sector->thinglist; thing != nullptr; thing = thing->snext)
{
DVector2 left, right;
if (!RenderPolySprite::GetLine(thing, left, right))
continue;
double distanceSquared = (thing->Pos() - ViewPos).LengthSquared();
RenderSprite(thing, distanceSquared, left, right);
}
}
std::stable_sort(TranslucentObjects.begin(), TranslucentObjects.end());
for (auto it = TranslucentObjects.rbegin(); it != TranslucentObjects.rend(); ++it)
{
auto &obj = *it;
if (obj.particle)
{
RenderPolyParticle spr;
spr.Render(WorldToClip, PortalPlane, obj.particle, obj.sub, obj.subsectorDepth, StencilValue + 1);
}
else if (!obj.thing)
{
obj.wall.Render(WorldToClip, PortalPlane);
}
else if ((obj.thing->renderflags & RF_SPRITETYPEMASK) == RF_WALLSPRITE)
{
RenderPolyWallSprite wallspr;
wallspr.Render(WorldToClip, PortalPlane, obj.thing, obj.sub, obj.subsectorDepth, StencilValue + 1);
}
else
{
RenderPolySprite spr;
spr.Render(WorldToClip, PortalPlane, obj.thing, obj.sub, obj.subsectorDepth, StencilValue + 1, obj.SpriteLeft, obj.SpriteRight);
}
}
}
/////////////////////////////////////////////////////////////////////////////
PolyDrawSectorPortal::PolyDrawSectorPortal(FSectorPortal *portal, bool ceiling) : Portal(portal), Ceiling(ceiling) PolyDrawSectorPortal::PolyDrawSectorPortal(FSectorPortal *portal, bool ceiling) : Portal(portal), Ceiling(ceiling)
{ {
StencilValue = RenderPolyScene::Instance()->GetNextStencilValue(); StencilValue = PolyRenderer::Instance()->GetNextStencilValue();
} }
void PolyDrawSectorPortal::Render(int portalDepth) void PolyDrawSectorPortal::Render(int portalDepth)
@ -356,7 +46,7 @@ void PolyDrawSectorPortal::Render(int portalDepth)
SaveGlobals(); SaveGlobals();
// To do: get this information from RenderPolyScene instead of duplicating the code.. // To do: get this information from PolyRenderer instead of duplicating the code..
double radPitch = ViewPitch.Normalized180().Radians(); double radPitch = ViewPitch.Normalized180().Radians();
double angx = cos(radPitch); double angx = cos(radPitch);
double angy = sin(radPitch) * glset.pixelstretch; double angy = sin(radPitch) * glset.pixelstretch;
@ -444,19 +134,19 @@ void PolyDrawSectorPortal::RestoreGlobals()
PolyDrawLinePortal::PolyDrawLinePortal(FLinePortal *portal) : Portal(portal) PolyDrawLinePortal::PolyDrawLinePortal(FLinePortal *portal) : Portal(portal)
{ {
StencilValue = RenderPolyScene::Instance()->GetNextStencilValue(); StencilValue = PolyRenderer::Instance()->GetNextStencilValue();
} }
PolyDrawLinePortal::PolyDrawLinePortal(line_t *mirror) : Mirror(mirror) PolyDrawLinePortal::PolyDrawLinePortal(line_t *mirror) : Mirror(mirror)
{ {
StencilValue = RenderPolyScene::Instance()->GetNextStencilValue(); StencilValue = PolyRenderer::Instance()->GetNextStencilValue();
} }
void PolyDrawLinePortal::Render(int portalDepth) void PolyDrawLinePortal::Render(int portalDepth)
{ {
SaveGlobals(); SaveGlobals();
// To do: get this information from RenderPolyScene instead of duplicating the code.. // To do: get this information from PolyRenderer instead of duplicating the code..
double radPitch = ViewPitch.Normalized180().Radians(); double radPitch = ViewPitch.Normalized180().Radians();
double angx = cos(radPitch); double angx = cos(radPitch);
double angy = sin(radPitch) * glset.pixelstretch; double angy = sin(radPitch) * glset.pixelstretch;

84
src/r_poly_portal.h
View file

@ -22,85 +22,7 @@
#pragma once #pragma once
#include <vector> #include "r_poly_scene.h"
#include <memory>
#include <algorithm>
#include <functional>
#include "doomdata.h"
#include "r_utility.h"
#include "r_main.h"
#include "r_poly_triangle.h"
#include "r_poly_intersection.h"
#include "r_poly_wall.h"
#include "r_poly_sprite.h"
#include "r_poly_wallsprite.h"
#include "r_poly_playersprite.h"
#include "r_poly_particle.h"
#include "r_poly_plane.h"
#include "r_poly_cull.h"
#include <set>
#include <unordered_map>
class PolyTranslucentObject
{
public:
PolyTranslucentObject(particle_t *particle, subsector_t *sub, uint32_t subsectorDepth) : particle(particle), sub(sub), subsectorDepth(subsectorDepth) { }
PolyTranslucentObject(AActor *thing, subsector_t *sub, uint32_t subsectorDepth, double dist, float t1, float t2) : thing(thing), sub(sub), subsectorDepth(subsectorDepth), DistanceSquared(dist), SpriteLeft(t1), SpriteRight(t2) { }
PolyTranslucentObject(RenderPolyWall wall) : wall(wall), subsectorDepth(wall.SubsectorDepth), DistanceSquared(1.e6) { }
bool operator<(const PolyTranslucentObject &other) const
{
return subsectorDepth != other.subsectorDepth ? subsectorDepth < other.subsectorDepth : DistanceSquared < other.DistanceSquared;
}
particle_t *particle = nullptr;
AActor *thing = nullptr;
subsector_t *sub = nullptr;
RenderPolyWall wall;
uint32_t subsectorDepth = 0;
double DistanceSquared = 0.0;
float SpriteLeft = 0.0f, SpriteRight = 1.0f;
};
class PolyDrawSectorPortal;
class PolyDrawLinePortal;
// Renders everything from a specific viewpoint
class RenderPolyPortal
{
public:
RenderPolyPortal();
~RenderPolyPortal();
void SetViewpoint(const TriMatrix &worldToClip, const Vec4f &portalPlane, uint32_t stencilValue);
void Render(int portalDepth);
void RenderTranslucent(int portalDepth);
static const uint32_t SkySubsectorDepth = 0x7fffffff;
private:
void ClearBuffers();
void RenderPortals(int portalDepth);
void RenderSectors();
void RenderSubsector(subsector_t *sub);
void RenderLine(subsector_t *sub, seg_t *line, sector_t *frontsector, uint32_t subsectorDepth);
void RenderSprite(AActor *thing, double sortDistance, const DVector2 &left, const DVector2 &right);
void RenderSprite(AActor *thing, double sortDistance, DVector2 left, DVector2 right, double t1, double t2, void *node);
TriMatrix WorldToClip;
Vec4f PortalPlane;
uint32_t StencilValue = 0;
PolyCull Cull;
uint32_t NextSubsectorDepth = 0;
std::set<sector_t *> SeenSectors;
std::unordered_map<subsector_t *, uint32_t> SubsectorDepths;
std::vector<PolyTranslucentObject> TranslucentObjects;
std::vector<std::unique_ptr<PolyDrawSectorPortal>> SectorPortals;
std::vector<std::unique_ptr<PolyDrawLinePortal>> LinePortals;
};
struct PolyPortalVertexRange struct PolyPortalVertexRange
{ {
@ -128,7 +50,7 @@ private:
void RestoreGlobals(); void RestoreGlobals();
bool Ceiling; bool Ceiling;
RenderPolyPortal RenderPortal; RenderPolyScene RenderPortal;
int savedextralight; int savedextralight;
DVector3 savedpos; DVector3 savedpos;
@ -156,7 +78,7 @@ private:
void SaveGlobals(); void SaveGlobals();
void RestoreGlobals(); void RestoreGlobals();
RenderPolyPortal RenderPortal; RenderPolyScene RenderPortal;
int savedextralight; int savedextralight;
DVector3 savedpos; DVector3 savedpos;

341
src/r_poly_scene.cpp Normal file
View file

@ -0,0 +1,341 @@
/*
** Polygon Doom software renderer
** 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 "p_maputl.h"
#include "sbar.h"
#include "r_data/r_translate.h"
#include "r_poly_scene.h"
#include "r_poly.h"
#include "gl/data/gl_data.h"
CVAR(Bool, r_debug_cull, 0, 0)
EXTERN_CVAR(Int, r_portal_recursions)
/////////////////////////////////////////////////////////////////////////////
RenderPolyScene::RenderPolyScene()
{
}
RenderPolyScene::~RenderPolyScene()
{
}
void RenderPolyScene::SetViewpoint(const TriMatrix &worldToClip, const Vec4f &portalPlane, uint32_t stencilValue)
{
WorldToClip = worldToClip;
StencilValue = stencilValue;
PortalPlane = portalPlane;
}
void RenderPolyScene::Render(int portalDepth)
{
ClearBuffers();
Cull.CullScene(WorldToClip, PortalPlane);
RenderSectors();
RenderPortals(portalDepth);
}
void RenderPolyScene::ClearBuffers()
{
SeenSectors.clear();
SubsectorDepths.clear();
TranslucentObjects.clear();
SectorPortals.clear();
LinePortals.clear();
NextSubsectorDepth = 0;
}
void RenderPolyScene::RenderSectors()
{
if (r_debug_cull)
{
for (auto it = Cull.PvsSectors.rbegin(); it != Cull.PvsSectors.rend(); ++it)
RenderSubsector(*it);
}
else
{
for (auto it = Cull.PvsSectors.begin(); it != Cull.PvsSectors.end(); ++it)
RenderSubsector(*it);
}
}
void RenderPolyScene::RenderSubsector(subsector_t *sub)
{
sector_t *frontsector = sub->sector;
frontsector->MoreFlags |= SECF_DRAWN;
uint32_t subsectorDepth = NextSubsectorDepth++;
if (sub->sector->CenterFloor() != sub->sector->CenterCeiling())
{
RenderPolyPlane::RenderPlanes(WorldToClip, PortalPlane, sub, subsectorDepth, StencilValue, Cull.MaxCeilingHeight, Cull.MinFloorHeight, SectorPortals);
}
for (uint32_t i = 0; i < sub->numlines; i++)
{
seg_t *line = &sub->firstline[i];
if (line->sidedef == nullptr || !(line->sidedef->Flags & WALLF_POLYOBJ))
{
RenderLine(sub, line, frontsector, subsectorDepth);
}
}
bool mainBSP = ((unsigned int)(sub - subsectors) < (unsigned int)numsubsectors);
if (mainBSP)
{
int subsectorIndex = (int)(sub - subsectors);
for (int i = ParticlesInSubsec[subsectorIndex]; i != NO_PARTICLE; i = Particles[i].snext)
{
particle_t *particle = Particles + i;
TranslucentObjects.push_back({ particle, sub, subsectorDepth });
}
}
SeenSectors.insert(sub->sector);
SubsectorDepths[sub] = subsectorDepth;
}
void RenderPolyScene::RenderSprite(AActor *thing, double sortDistance, const DVector2 &left, const DVector2 &right)
{
if (numnodes == 0)
RenderSprite(thing, sortDistance, left, right, 0.0, 1.0, subsectors);
else
RenderSprite(thing, sortDistance, left, right, 0.0, 1.0, nodes + numnodes - 1); // The head node is the last node output.
}
void RenderPolyScene::RenderSprite(AActor *thing, double sortDistance, DVector2 left, DVector2 right, double t1, double t2, void *node)
{
while (!((size_t)node & 1)) // Keep going until found a subsector
{
node_t *bsp = (node_t *)node;
DVector2 planePos(FIXED2DBL(bsp->x), FIXED2DBL(bsp->y));
DVector2 planeNormal = DVector2(FIXED2DBL(-bsp->dy), FIXED2DBL(bsp->dx));
double planeD = planeNormal | planePos;
int sideLeft = (left | planeNormal) > planeD;
int sideRight = (right | planeNormal) > planeD;
if (sideLeft != sideRight)
{
double dotLeft = planeNormal | left;
double dotRight = planeNormal | right;
double t = (planeD - dotLeft) / (dotRight - dotLeft);
DVector2 mid = left * (1.0 - t) + right * t;
double tmid = t1 * (1.0 - t) + t2 * t;
RenderSprite(thing, sortDistance, mid, right, tmid, t2, bsp->children[sideRight]);
right = mid;
t2 = tmid;
}
node = bsp->children[sideLeft];
}
subsector_t *sub = (subsector_t *)((BYTE *)node - 1);
auto it = SubsectorDepths.find(sub);
if (it != SubsectorDepths.end())
TranslucentObjects.push_back({ thing, sub, it->second, sortDistance, (float)t1, (float)t2 });
}
void RenderPolyScene::RenderLine(subsector_t *sub, seg_t *line, sector_t *frontsector, uint32_t subsectorDepth)
{
// 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;
// Cull wall if not visible
int sx1, sx2;
LineSegmentRange segmentRange = Cull.GetSegmentRangeForLine(line->v1->fX(), line->v1->fY(), line->v2->fX(), line->v2->fY(), sx1, sx2);
if (segmentRange == LineSegmentRange::NotVisible || (segmentRange == LineSegmentRange::HasSegment && Cull.IsSegmentCulled(sx1, sx2)))
return;
// Tell automap we saw this
if (!swrenderer::r_dontmaplines && line->linedef && segmentRange != LineSegmentRange::AlwaysVisible)
{
line->linedef->flags |= ML_MAPPED;
sub->flags |= SSECF_DRAWN;
}
// Render 3D floor sides
if (line->backsector && frontsector->e && line->backsector->e->XFloor.ffloors.Size())
{
for (unsigned int i = 0; i < line->backsector->e->XFloor.ffloors.Size(); i++)
{
F3DFloor *fakeFloor = line->backsector->e->XFloor.ffloors[i];
if (!(fakeFloor->flags & FF_EXISTS)) continue;
if (!(fakeFloor->flags & FF_RENDERPLANES)) continue;
if (!fakeFloor->model) continue;
RenderPolyWall::Render3DFloorLine(WorldToClip, PortalPlane, line, frontsector, subsectorDepth, StencilValue, fakeFloor, TranslucentObjects);
}
}
// Render wall, and update culling info if its an occlusion blocker
if (RenderPolyWall::RenderLine(WorldToClip, PortalPlane, line, frontsector, subsectorDepth, StencilValue, TranslucentObjects, LinePortals))
{
if (segmentRange == LineSegmentRange::HasSegment)
Cull.MarkSegmentCulled(sx1, sx2);
}
}
void RenderPolyScene::RenderPortals(int portalDepth)
{
if (portalDepth < r_portal_recursions)
{
for (auto &portal : SectorPortals)
portal->Render(portalDepth + 1);
for (auto &portal : LinePortals)
portal->Render(portalDepth + 1);
}
else // Fill with black
{
PolyDrawArgs args;
args.objectToClip = &WorldToClip;
args.mode = TriangleDrawMode::Fan;
args.uniforms.color = 0;
args.uniforms.light = 256;
args.uniforms.flags = TriUniforms::fixed_light;
args.SetClipPlane(PortalPlane.x, PortalPlane.y, PortalPlane.z, PortalPlane.w);
for (auto &portal : SectorPortals)
{
args.stenciltestvalue = portal->StencilValue;
args.stencilwritevalue = portal->StencilValue + 1;
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::FillNormal, TriBlendMode::Copy);
}
}
for (auto &portal : LinePortals)
{
args.stenciltestvalue = portal->StencilValue;
args.stencilwritevalue = portal->StencilValue + 1;
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::FillNormal, TriBlendMode::Copy);
}
}
}
}
void RenderPolyScene::RenderTranslucent(int portalDepth)
{
if (portalDepth < r_portal_recursions)
{
for (auto it = SectorPortals.rbegin(); it != SectorPortals.rend(); ++it)
{
auto &portal = *it;
portal->RenderTranslucent(portalDepth + 1);
PolyDrawArgs args;
args.objectToClip = &WorldToClip;
args.mode = TriangleDrawMode::Fan;
args.stenciltestvalue = portal->StencilValue + 1;
args.stencilwritevalue = StencilValue;
args.SetClipPlane(PortalPlane.x, PortalPlane.y, PortalPlane.z, PortalPlane.w);
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::StencilClose, TriBlendMode::Copy);
}
}
for (auto it = LinePortals.rbegin(); it != LinePortals.rend(); ++it)
{
auto &portal = *it;
portal->RenderTranslucent(portalDepth + 1);
PolyDrawArgs args;
args.objectToClip = &WorldToClip;
args.mode = TriangleDrawMode::Fan;
args.stenciltestvalue = portal->StencilValue + 1;
args.stencilwritevalue = StencilValue;
args.SetClipPlane(PortalPlane.x, PortalPlane.y, PortalPlane.z, PortalPlane.w);
for (const auto &verts : portal->Shape)
{
args.vinput = verts.Vertices;
args.vcount = verts.Count;
args.ccw = verts.Ccw;
args.uniforms.subsectorDepth = verts.SubsectorDepth;
PolyTriangleDrawer::draw(args, TriDrawVariant::StencilClose, TriBlendMode::Copy);
}
}
}
for (sector_t *sector : SeenSectors)
{
for (AActor *thing = sector->thinglist; thing != nullptr; thing = thing->snext)
{
DVector2 left, right;
if (!RenderPolySprite::GetLine(thing, left, right))
continue;
double distanceSquared = (thing->Pos() - ViewPos).LengthSquared();
RenderSprite(thing, distanceSquared, left, right);
}
}
std::stable_sort(TranslucentObjects.begin(), TranslucentObjects.end());
for (auto it = TranslucentObjects.rbegin(); it != TranslucentObjects.rend(); ++it)
{
auto &obj = *it;
if (obj.particle)
{
RenderPolyParticle spr;
spr.Render(WorldToClip, PortalPlane, obj.particle, obj.sub, obj.subsectorDepth, StencilValue + 1);
}
else if (!obj.thing)
{
obj.wall.Render(WorldToClip, PortalPlane);
}
else if ((obj.thing->renderflags & RF_SPRITETYPEMASK) == RF_WALLSPRITE)
{
RenderPolyWallSprite wallspr;
wallspr.Render(WorldToClip, PortalPlane, obj.thing, obj.sub, obj.subsectorDepth, StencilValue + 1);
}
else
{
RenderPolySprite spr;
spr.Render(WorldToClip, PortalPlane, obj.thing, obj.sub, obj.subsectorDepth, StencilValue + 1, obj.SpriteLeft, obj.SpriteRight);
}
}
}

103
src/r_poly_scene.h Normal file
View file

@ -0,0 +1,103 @@
/*
** Polygon Doom software renderer
** 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.
**
*/
#pragma once
#include <vector>
#include <memory>
#include <algorithm>
#include <functional>
#include "doomdata.h"
#include "r_utility.h"
#include "r_main.h"
#include "r_poly_triangle.h"
#include "r_poly_intersection.h"
#include "r_poly_wall.h"
#include "r_poly_sprite.h"
#include "r_poly_wallsprite.h"
#include "r_poly_playersprite.h"
#include "r_poly_particle.h"
#include "r_poly_plane.h"
#include "r_poly_cull.h"
#include <set>
#include <unordered_map>
class PolyTranslucentObject
{
public:
PolyTranslucentObject(particle_t *particle, subsector_t *sub, uint32_t subsectorDepth) : particle(particle), sub(sub), subsectorDepth(subsectorDepth) { }
PolyTranslucentObject(AActor *thing, subsector_t *sub, uint32_t subsectorDepth, double dist, float t1, float t2) : thing(thing), sub(sub), subsectorDepth(subsectorDepth), DistanceSquared(dist), SpriteLeft(t1), SpriteRight(t2) { }
PolyTranslucentObject(RenderPolyWall wall) : wall(wall), subsectorDepth(wall.SubsectorDepth), DistanceSquared(1.e6) { }
bool operator<(const PolyTranslucentObject &other) const
{
return subsectorDepth != other.subsectorDepth ? subsectorDepth < other.subsectorDepth : DistanceSquared < other.DistanceSquared;
}
particle_t *particle = nullptr;
AActor *thing = nullptr;
subsector_t *sub = nullptr;
RenderPolyWall wall;
uint32_t subsectorDepth = 0;
double DistanceSquared = 0.0;
float SpriteLeft = 0.0f, SpriteRight = 1.0f;
};
class PolyDrawSectorPortal;
class PolyDrawLinePortal;
// Renders everything from a specific viewpoint
class RenderPolyScene
{
public:
RenderPolyScene();
~RenderPolyScene();
void SetViewpoint(const TriMatrix &worldToClip, const Vec4f &portalPlane, uint32_t stencilValue);
void Render(int portalDepth);
void RenderTranslucent(int portalDepth);
static const uint32_t SkySubsectorDepth = 0x7fffffff;
private:
void ClearBuffers();
void RenderPortals(int portalDepth);
void RenderSectors();
void RenderSubsector(subsector_t *sub);
void RenderLine(subsector_t *sub, seg_t *line, sector_t *frontsector, uint32_t subsectorDepth);
void RenderSprite(AActor *thing, double sortDistance, const DVector2 &left, const DVector2 &right);
void RenderSprite(AActor *thing, double sortDistance, DVector2 left, DVector2 right, double t1, double t2, void *node);
TriMatrix WorldToClip;
Vec4f PortalPlane;
uint32_t StencilValue = 0;
PolyCull Cull;
uint32_t NextSubsectorDepth = 0;
std::set<sector_t *> SeenSectors;
std::unordered_map<subsector_t *, uint32_t> SubsectorDepths;
std::vector<PolyTranslucentObject> TranslucentObjects;
std::vector<std::unique_ptr<PolyDrawSectorPortal>> SectorPortals;
std::vector<std::unique_ptr<PolyDrawLinePortal>> LinePortals;
};

2
src/r_poly_sky.cpp
View file

@ -55,7 +55,7 @@ void PolySkyDome::Render(const TriMatrix &worldToClip)
PolyDrawArgs args; PolyDrawArgs args;
args.uniforms.light = 256; args.uniforms.light = 256;
args.uniforms.flags = 0; args.uniforms.flags = 0;
args.uniforms.subsectorDepth = RenderPolyPortal::SkySubsectorDepth; args.uniforms.subsectorDepth = RenderPolyScene::SkySubsectorDepth;
args.objectToClip = &objectToClip; args.objectToClip = &objectToClip;
args.stenciltestvalue = 255; args.stenciltestvalue = 255;
args.stencilwritevalue = 255; args.stencilwritevalue = 255;

8
src/r_swrenderer.cpp
View file

@ -195,7 +195,7 @@ void FSoftwareRenderer::RenderView(player_t *player)
bool saved_swtruecolor = r_swtruecolor; bool saved_swtruecolor = r_swtruecolor;
r_swtruecolor = screen->IsBgra(); r_swtruecolor = screen->IsBgra();
RenderPolyScene::Instance()->RenderActorView(player->mo, false); PolyRenderer::Instance()->RenderActorView(player->mo, false);
FCanvasTextureInfo::UpdateAll(); FCanvasTextureInfo::UpdateAll();
// Apply special colormap if the target cannot do it // Apply special colormap if the target cannot do it
@ -260,7 +260,7 @@ void FSoftwareRenderer::WriteSavePic (player_t *player, FileWriter *file, int wi
pic->ObjectFlags |= OF_Fixed; pic->ObjectFlags |= OF_Fixed;
pic->Lock (); pic->Lock ();
if (r_polyrenderer) if (r_polyrenderer)
RenderPolyScene::Instance()->RenderViewToCanvas(player->mo, pic, 0, 0, width, height, true); PolyRenderer::Instance()->RenderViewToCanvas(player->mo, pic, 0, 0, width, height, true);
else else
R_RenderViewToCanvas (player->mo, pic, 0, 0, width, height); R_RenderViewToCanvas (player->mo, pic, 0, 0, width, height);
screen->GetFlashedPalette (palette); screen->GetFlashedPalette (palette);
@ -285,7 +285,7 @@ void FSoftwareRenderer::DrawRemainingPlayerSprites()
} }
else else
{ {
RenderPolyScene::Instance()->RenderRemainingPlayerSprites(); PolyRenderer::Instance()->RenderRemainingPlayerSprites();
} }
} }
@ -413,7 +413,7 @@ void FSoftwareRenderer::RenderTextureView (FCanvasTexture *tex, AActor *viewpoin
DAngle savedfov = FieldOfView; DAngle savedfov = FieldOfView;
R_SetFOV ((double)fov); R_SetFOV ((double)fov);
if (r_polyrenderer) if (r_polyrenderer)
RenderPolyScene::Instance()->RenderViewToCanvas(viewpoint, Canvas, 0, 0, tex->GetWidth(), tex->GetHeight(), tex->bFirstUpdate); PolyRenderer::Instance()->RenderViewToCanvas(viewpoint, Canvas, 0, 0, tex->GetWidth(), tex->GetHeight(), tex->bFirstUpdate);
else else
R_RenderViewToCanvas (viewpoint, Canvas, 0, 0, tex->GetWidth(), tex->GetHeight(), tex->bFirstUpdate); R_RenderViewToCanvas (viewpoint, Canvas, 0, 0, tex->GetWidth(), tex->GetHeight(), tex->bFirstUpdate);
R_SetFOV (savedfov); R_SetFOV (savedfov);