mirror of
https://github.com/ZDoom/Raze.git
synced 2024-11-16 01:11:44 +00:00
7a03967ceb
We need to reset the gotsector array for that, but since we also need the accumulate result of both passes there's now two such arrays.
1160 lines
No EOL
31 KiB
C++
1160 lines
No EOL
31 KiB
C++
//
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Copyright(C) 2000-2016 Christoph Oelckers
|
|
// All rights reserved.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with this program. If not, see http://www.gnu.org/licenses/
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
//
|
|
|
|
#include "texturemanager.h"
|
|
#include "hw_dynlightdata.h"
|
|
#include "hw_material.h"
|
|
#include "hw_cvars.h"
|
|
#include "hw_clock.h"
|
|
//#include "hw_lighting.h"
|
|
#include "hw_drawinfo.h"
|
|
#include "hw_portal.h"
|
|
#include "hw_lightbuffer.h"
|
|
#include "hw_renderstate.h"
|
|
#include "hw_skydome.h"
|
|
#include "hw_drawstructs.h"
|
|
#include "gamefuncs.h"
|
|
#include "cmdlib.h"
|
|
|
|
#include "v_video.h"
|
|
#include "flatvertices.h"
|
|
#include "glbackend/glbackend.h"
|
|
|
|
extern PalEntry GlobalMapFog;
|
|
extern float GlobalFogDensity;
|
|
|
|
//==========================================================================
|
|
//
|
|
// Create vertices for one wall
|
|
//
|
|
//==========================================================================
|
|
|
|
int HWWall::CreateVertices(FFlatVertex*& ptr, bool split)
|
|
{
|
|
auto oo = ptr;
|
|
ptr->Set(glseg.x1, zbottom[0], glseg.y1, tcs[LOLFT].u, tcs[LOLFT].v);
|
|
ptr++;
|
|
ptr->Set(glseg.x1, ztop[0], glseg.y1, tcs[UPLFT].u, tcs[UPLFT].v);
|
|
ptr++;
|
|
ptr->Set(glseg.x2, ztop[1], glseg.y2, tcs[UPRGT].u, tcs[UPRGT].v);
|
|
ptr++;
|
|
ptr->Set(glseg.x2, zbottom[1], glseg.y2, tcs[LORGT].u, tcs[LORGT].v);
|
|
ptr++;
|
|
return int(ptr - oo);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// build the vertices for this wall
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::MakeVertices(HWDrawInfo* di, bool nosplit)
|
|
{
|
|
if (vertcount == 0)
|
|
{
|
|
auto ret = screen->mVertexData->AllocVertices(4);
|
|
vertindex = ret.second;
|
|
vertcount = CreateVertices(ret.first, false);
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// General purpose wall rendering function
|
|
// everything goes through here
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::RenderWall(HWDrawInfo *di, FRenderState &state, int textured)
|
|
{
|
|
assert(vertcount > 0);
|
|
state.SetLightIndex(dynlightindex);
|
|
state.Draw(DT_TriangleFan, vertindex, vertcount);
|
|
vertexcount += vertcount;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::RenderFogBoundary(HWDrawInfo *di, FRenderState &state)
|
|
{
|
|
if (gl_fogmode)// && !di->isFullbrightScene())
|
|
{
|
|
state.EnableDrawBufferAttachments(false);
|
|
SetLightAndFog(state);
|
|
state.SetEffect(EFF_FOGBOUNDARY);
|
|
state.AlphaFunc(Alpha_GEqual, 0.f);
|
|
state.SetDepthBias(-1, -128);
|
|
RenderWall(di, state, HWWall::RWF_BLANK);
|
|
state.ClearDepthBias();
|
|
state.SetEffect(EFF_NONE);
|
|
state.EnableDrawBufferAttachments(true);
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::SetLightAndFog(FRenderState& state)
|
|
{
|
|
// Fog must be done before the texture so that the texture selector can override it.
|
|
bool foggy = (GlobalMapFog || (fade & 0xffffff));
|
|
auto ShadeDiv = lookups.tables[palette].ShadeFactor;
|
|
// Disable brightmaps if non-black fog is used.
|
|
if (ShadeDiv >= 1 / 1000.f && foggy)
|
|
{
|
|
state.EnableFog(1);
|
|
float density = GlobalMapFog ? GlobalFogDensity : 350.f - Scale(numshades - shade, 150, numshades);
|
|
state.SetFog((GlobalMapFog) ? GlobalMapFog : fade, density * hw_density);
|
|
state.SetSoftLightLevel(255);
|
|
state.SetLightParms(128.f, 1 / 1000.f);
|
|
}
|
|
else
|
|
{
|
|
state.EnableFog(0);
|
|
state.SetFog(0, 0);
|
|
state.SetSoftLightLevel(ShadeDiv >= 1 / 1000.f ? 255 - Scale(shade, 255, numshades) : 255);
|
|
state.SetLightParms(visibility, ShadeDiv / (numshades - 2));
|
|
}
|
|
|
|
// The shade rgb from the tint is ignored here.
|
|
state.SetColorAlpha(PalEntry(255, globalr, globalg, globalb), alpha);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
void HWWall::RenderMirrorSurface(HWDrawInfo *di, FRenderState &state)
|
|
{
|
|
if (!TexMan.mirrorTexture.isValid()) return;
|
|
|
|
state.SetDepthFunc(DF_LEqual);
|
|
|
|
// we use texture coordinates and texture matrix to pass the normal stuff to the shader so that the default vertex buffer format can be used as is.
|
|
state.EnableTextureMatrix(true);
|
|
|
|
// Use sphere mapping for this
|
|
state.SetEffect(EFF_SPHEREMAP);
|
|
SetLightAndFog(state);
|
|
state.SetColor(PalEntry(25, globalr >> 1, globalg >> 1, globalb >> 1));
|
|
|
|
state.SetRenderStyle(STYLE_Add);
|
|
state.AlphaFunc(Alpha_Greater, 0);
|
|
|
|
auto tex = TexMan.GetGameTexture(TexMan.mirrorTexture, false);
|
|
state.SetMaterial(tex, UF_None, 0, CLAMP_NONE, 0, -1); // do not upscale the mirror texture.
|
|
|
|
RenderWall(di, state, HWWall::RWF_BLANK);
|
|
|
|
state.EnableTextureMatrix(false);
|
|
state.SetEffect(EFF_NONE);
|
|
state.AlphaFunc(Alpha_GEqual, gl_mask_sprite_threshold);
|
|
|
|
state.SetDepthFunc(DF_Less);
|
|
state.SetRenderStyle(STYLE_Translucent);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::RenderTexturedWall(HWDrawInfo *di, FRenderState &state, int rflags)
|
|
{
|
|
SetLightAndFog(state);
|
|
state.SetMaterial(texture, UF_Texture, 0, sprite == nullptr ? (flags & (HWF_CLAMPX | HWF_CLAMPY)) : CLAMP_XY, TRANSLATION(Translation_Remap + curbasepal, palette), -1);
|
|
|
|
int h = (int)texture->GetDisplayHeight();
|
|
int h2 = 1 << sizeToBits(h);
|
|
if (h2 < h) h2 *= 2;
|
|
if (h != h2)
|
|
{
|
|
float xOffset = 1.f / texture->GetDisplayWidth();
|
|
state.SetNpotEmulation(float(h2) / h, xOffset);
|
|
}
|
|
else
|
|
{
|
|
state.SetNpotEmulation(0.f, 0.f);
|
|
}
|
|
|
|
RenderWall(di, state, rflags);
|
|
|
|
state.SetNpotEmulation(0.f, 0.f);
|
|
/* none of these functions is in use.
|
|
state.SetObjectColor(0xffffffff);
|
|
state.SetObjectColor2(0);
|
|
state.SetAddColor(0);
|
|
state.SetTextureMode(tmode);
|
|
state.EnableGlow(false);
|
|
state.EnableGradient(false);
|
|
state.ApplyTextureManipulation(nullptr);
|
|
*/
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::RenderTranslucentWall(HWDrawInfo *di, FRenderState &state)
|
|
{
|
|
if (RenderStyle.BlendOp != STYLEOP_Add)
|
|
{
|
|
state.EnableBrightmap(false);
|
|
}
|
|
|
|
state.SetRenderStyle(RenderStyle);
|
|
state.SetTextureMode(RenderStyle);
|
|
if (!texture->GetTranslucency()) state.AlphaFunc(Alpha_GEqual, gl_mask_threshold);
|
|
else state.AlphaFunc(Alpha_GEqual, 0.f);
|
|
RenderTexturedWall(di, state, HWWall::RWF_TEXTURED);
|
|
state.SetRenderStyle(STYLE_Translucent);
|
|
state.EnableBrightmap(true);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
void HWWall::DrawWall(HWDrawInfo *di, FRenderState &state, bool translucent)
|
|
{
|
|
if (screen->BuffersArePersistent())
|
|
{
|
|
/*
|
|
if (di->Level->HasDynamicLights && !di->isFullbrightScene() && texture != nullptr)
|
|
{
|
|
SetupLights(di, lightdata);
|
|
}
|
|
*/
|
|
MakeVertices(di, !!(flags & HWWall::HWF_TRANSLUCENT));
|
|
}
|
|
|
|
state.SetNormal(glseg.Normal());
|
|
if (!translucent)
|
|
{
|
|
RenderTexturedWall(di, state, HWWall::RWF_TEXTURED);
|
|
}
|
|
else
|
|
{
|
|
switch (type)
|
|
{
|
|
case RENDERWALL_MIRRORSURFACE:
|
|
RenderMirrorSurface(di, state);
|
|
break;
|
|
|
|
case RENDERWALL_FOGBOUNDARY:
|
|
RenderFogBoundary(di, state);
|
|
break;
|
|
|
|
default:
|
|
RenderTranslucentWall(di, state);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Collect lights for shader
|
|
//
|
|
//==========================================================================
|
|
#if 0
|
|
void HWWall::SetupLights(HWDrawInfo *di, FDynLightData &lightdata)
|
|
{
|
|
lightdata.Clear();
|
|
|
|
if (RenderStyle == STYLE_Add && !di->Level->lightadditivesurfaces) return; // no lights on additively blended surfaces.
|
|
|
|
// check for wall types which cannot have dynamic lights on them (portal types never get here so they don't need to be checked.)
|
|
switch (type)
|
|
{
|
|
case RENDERWALL_FOGBOUNDARY:
|
|
case RENDERWALL_MIRRORSURFACE:
|
|
case RENDERWALL_COLOR:
|
|
return;
|
|
}
|
|
|
|
float vtx[]={glseg.x1,zbottom[0],glseg.y1, glseg.x1,ztop[0],glseg.y1, glseg.x2,ztop[1],glseg.y2, glseg.x2,zbottom[1],glseg.y2};
|
|
Plane p;
|
|
|
|
|
|
auto normal = glseg.Normal();
|
|
p.Set(normal, -normal.X * glseg.x1 - normal.Z * glseg.y1);
|
|
|
|
FLightNode *node;
|
|
if (seg->sidedef == NULL)
|
|
{
|
|
node = NULL;
|
|
}
|
|
else if (!(seg->sidedef->Flags & WALLF_POLYOBJ))
|
|
{
|
|
node = seg->sidedef->lighthead;
|
|
}
|
|
else if (sub)
|
|
{
|
|
// Polobject segs cannot be checked per sidedef so use the subsector instead.
|
|
node = sub->section->lighthead;
|
|
}
|
|
else node = NULL;
|
|
|
|
// Iterate through all dynamic lights which touch this wall and render them
|
|
while (node)
|
|
{
|
|
if (node->lightsource->IsActive())
|
|
{
|
|
iter_dlight++;
|
|
|
|
DVector3 posrel = node->lightsource->PosRelative(seg->frontsector->PortalGroup);
|
|
float x = posrel.X;
|
|
float y = posrel.Y;
|
|
float z = posrel.Z;
|
|
float dist = fabsf(p.DistToPoint(x, z, y));
|
|
float radius = node->lightsource->GetRadius();
|
|
float scale = 1.0f / ((2.f * radius) - dist);
|
|
FVector3 fn, pos;
|
|
|
|
if (radius > 0.f && dist < radius)
|
|
{
|
|
FVector3 nearPt, up, right;
|
|
|
|
pos = { x, z, y };
|
|
fn = p.Normal();
|
|
|
|
fn.GetRightUp(right, up);
|
|
|
|
FVector3 tmpVec = fn * dist;
|
|
nearPt = pos + tmpVec;
|
|
|
|
FVector3 t1;
|
|
int outcnt[4]={0,0,0,0};
|
|
texcoord tcs[4];
|
|
|
|
// do a quick check whether the light touches this polygon
|
|
for(int i=0;i<4;i++)
|
|
{
|
|
t1 = FVector3(&vtx[i*3]);
|
|
FVector3 nearToVert = t1 - nearPt;
|
|
tcs[i].u = ((nearToVert | right) * scale) + 0.5f;
|
|
tcs[i].v = ((nearToVert | up) * scale) + 0.5f;
|
|
|
|
if (tcs[i].u<0) outcnt[0]++;
|
|
if (tcs[i].u>1) outcnt[1]++;
|
|
if (tcs[i].v<0) outcnt[2]++;
|
|
if (tcs[i].v>1) outcnt[3]++;
|
|
|
|
}
|
|
if (outcnt[0]!=4 && outcnt[1]!=4 && outcnt[2]!=4 && outcnt[3]!=4)
|
|
{
|
|
draw_dlight += GetLight(lightdata, seg->frontsector->PortalGroup, p, node->lightsource, true);
|
|
}
|
|
}
|
|
}
|
|
node = node->nextLight;
|
|
}
|
|
dynlightindex = screen->mLights->UploadLights(lightdata);
|
|
}
|
|
#endif
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
void HWWall::PutWall(HWDrawInfo *di, bool translucent)
|
|
{
|
|
if (translucent || (texture && texture->GetTranslucency() && type == RENDERWALL_M2S))
|
|
{
|
|
flags |= HWF_TRANSLUCENT;
|
|
ViewDistance = (di->Viewpoint.Pos.XY() - DVector2((glseg.x1 + glseg.x2) * 0.5f, (glseg.y1 + glseg.y2) * 0.5f)).LengthSquared();
|
|
}
|
|
|
|
if (texture->isHardwareCanvas())
|
|
{
|
|
tcs[UPLFT].v = 1.f - tcs[UPLFT].v;
|
|
tcs[LOLFT].v = 1.f - tcs[LOLFT].v;
|
|
tcs[UPRGT].v = 1.f - tcs[UPRGT].v;
|
|
tcs[LORGT].v = 1.f - tcs[LORGT].v;
|
|
}
|
|
|
|
|
|
if (!screen->BuffersArePersistent())
|
|
{
|
|
/*
|
|
if (di->Level->HasDynamicLights && !di->isFullbrightScene() && texture != nullptr)
|
|
{
|
|
SetupLights(di, lightdata);
|
|
}
|
|
*/
|
|
MakeVertices(di, translucent);
|
|
}
|
|
|
|
di->AddWall(this);
|
|
// make sure that following parts of the same linedef do not get this one's vertex and lighting info.
|
|
vertcount = 0;
|
|
dynlightindex = -1;
|
|
flags &= ~(HWF_TRANSLUCENT|HWF_CLAMPX|HWF_CLAMPY);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// will be done later.
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::PutPortal(HWDrawInfo *di, int ptype, int plane)
|
|
{
|
|
HWPortal * portal = nullptr;
|
|
|
|
MakeVertices(di, false);
|
|
switch (ptype)
|
|
{
|
|
#if 0
|
|
// portals don't go into the draw list.
|
|
// Instead they are added to the portal manager
|
|
case PORTALTYPE_HORIZON:
|
|
horizon = portalState.UniqueHorizons.Get(horizon);
|
|
portal = di->FindPortal(horizon);
|
|
if (!portal)
|
|
{
|
|
portal = new HWHorizonPortal(&portalState, horizon, di->Viewpoint);
|
|
di->Portals.Push(portal);
|
|
}
|
|
portal->AddLine(this);
|
|
break;
|
|
|
|
case PORTALTYPE_SKYBOX:
|
|
portal = di->FindPortal(secportal);
|
|
if (!portal)
|
|
{
|
|
// either a regular skybox or an Eternity-style horizon
|
|
if (secportal->mType != PORTS_SKYVIEWPOINT) portal = new HWEEHorizonPortal(&portalState, secportal);
|
|
else
|
|
{
|
|
portal = new HWSkyboxPortal(&portalState, secportal);
|
|
di->Portals.Push(portal);
|
|
}
|
|
}
|
|
portal->AddLine(this);
|
|
break;
|
|
#endif
|
|
|
|
case PORTALTYPE_SECTORSTACK:
|
|
portal = di->FindPortal(this->portal);
|
|
if (!portal)
|
|
{
|
|
portal = new HWSectorStackPortal(&portalState, this->portal);
|
|
di->Portals.Push(portal);
|
|
}
|
|
portal->AddLine(this);
|
|
break;
|
|
|
|
#if 0
|
|
case PORTALTYPE_PLANEMIRROR:
|
|
if (portalState.PlaneMirrorMode * planemirror->fC() <= 0)
|
|
{
|
|
planemirror = portalState.UniquePlaneMirrors.Get(planemirror);
|
|
portal = di->FindPortal(planemirror);
|
|
if (!portal)
|
|
{
|
|
portal = new HWPlaneMirrorPortal(&portalState, planemirror);
|
|
di->Portals.Push(portal);
|
|
}
|
|
portal->AddLine(this);
|
|
}
|
|
break;
|
|
#endif
|
|
case PORTALTYPE_MIRROR:
|
|
// These are unique. No need to look existing ones up.
|
|
portal = new HWMirrorPortal(&portalState, seg);
|
|
di->Portals.Push(portal);
|
|
portal->AddLine(this);
|
|
if (gl_mirror_envmap)
|
|
{
|
|
// draw a reflective layer over the mirror
|
|
di->AddMirrorSurface(this);
|
|
}
|
|
break;
|
|
|
|
case PORTALTYPE_LINETOLINE:
|
|
// These are also unique.
|
|
portal = new HWLineToLinePortal(&portalState, seg, &wall[seg->portalnum]);
|
|
di->Portals.Push(portal);
|
|
portal->AddLine(this);
|
|
break;
|
|
|
|
case PORTALTYPE_LINETOSPRITE:
|
|
// These are also unique.
|
|
portal = new HWLineToSpritePortal(&portalState, seg, &sprite[seg->portalnum]);
|
|
di->Portals.Push(portal);
|
|
portal->AddLine(this);
|
|
break;
|
|
|
|
case PORTALTYPE_SKY:
|
|
sky = portalState.UniqueSkies.Get(sky);
|
|
portal = di->FindPortal(sky);
|
|
if (!portal)
|
|
{
|
|
portal = new HWSkyPortal(screen->mSkyData, &portalState, sky);
|
|
di->Portals.Push(portal);
|
|
}
|
|
portal->AddLine(this);
|
|
break;
|
|
}
|
|
vertcount = 0;
|
|
|
|
if (plane != -1 && portal)
|
|
{
|
|
portal->planesused |= (1<<plane);
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Build does not have horizon effects.
|
|
//
|
|
//==========================================================================
|
|
bool HWWall::DoHorizon(HWDrawInfo* di, walltype* seg, sectortype* fs, DVector2& v1, DVector2& v2)
|
|
{
|
|
#if 0
|
|
HWHorizonInfo hi;
|
|
lightlist_t * light;
|
|
|
|
// ZDoom doesn't support slopes in a horizon sector so I won't either!
|
|
ztop[1] = ztop[0] = fs->GetPlaneTexZ(sector_t::ceiling);
|
|
zbottom[1] = zbottom[0] = fs->GetPlaneTexZ(sector_t::floor);
|
|
|
|
auto vpz = di->Viewpoint.Pos.Z;
|
|
if (vpz < fs->GetPlaneTexZ(sector_t::ceiling))
|
|
{
|
|
if (vpz > fs->GetPlaneTexZ(sector_t::floor))
|
|
zbottom[1] = zbottom[0] = vpz;
|
|
|
|
if (fs->GetTexture(sector_t::ceiling) == skyflatnum)
|
|
{
|
|
SkyPlane(di, fs, sector_t::ceiling, false);
|
|
}
|
|
else
|
|
{
|
|
horizon = &hi;
|
|
PutPortal(di, PORTALTYPE_HORIZON, -1);
|
|
}
|
|
ztop[1] = ztop[0] = zbottom[0];
|
|
}
|
|
|
|
if (vpz > fs->GetPlaneTexZ(sector_t::floor))
|
|
{
|
|
zbottom[1] = zbottom[0] = fs->GetPlaneTexZ(sector_t::floor);
|
|
if (fs->GetTexture(sector_t::floor) == skyflatnum)
|
|
{
|
|
SkyPlane(di, fs, sector_t::floor, false);
|
|
}
|
|
else
|
|
{
|
|
horizon = &hi;
|
|
PutPortal(di, PORTALTYPE_HORIZON, -1);
|
|
}
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
bool HWWall::SetWallCoordinates(walltype * seg, float topleft, float topright, float bottomleft, float bottomright)
|
|
{
|
|
//
|
|
//
|
|
// set up coordinates for the left side of the polygon
|
|
//
|
|
// check left side for intersections
|
|
if (topleft >= bottomleft)
|
|
{
|
|
// normal case
|
|
ztop[0] = topleft;
|
|
zbottom[0] = bottomleft;
|
|
}
|
|
else
|
|
{
|
|
// ceiling below floor - clip to the visible part of the wall
|
|
float dch = topright - topleft;
|
|
float dfh = bottomright - bottomleft;
|
|
float inter_x = (bottomleft - topleft) / (dch - dfh);
|
|
float inter_y = topleft + inter_x * dch;
|
|
|
|
glseg.x1 = glseg.x1 + inter_x * (glseg.x2 - glseg.x1);
|
|
glseg.y1 = glseg.y1 + inter_x * (glseg.y2 - glseg.y1);
|
|
glseg.fracleft = inter_x;
|
|
|
|
zbottom[0] = ztop[0] = inter_y;
|
|
}
|
|
|
|
//
|
|
//
|
|
// set up coordinates for the right side of the polygon
|
|
//
|
|
// check left side for intersections
|
|
if (topright >= bottomright)
|
|
{
|
|
// normal case
|
|
ztop[1] = topright;
|
|
zbottom[1] = bottomright;
|
|
}
|
|
else
|
|
{
|
|
// ceiling below floor - clip to the visible part of the wall
|
|
float dch = topright - topleft;
|
|
float dfh = bottomright - bottomleft;
|
|
float inter_x = (bottomleft - topleft) / (dch - dfh);
|
|
|
|
float inter_y = topleft + inter_x * dch;
|
|
|
|
glseg.x2 = glseg.x1 + inter_x * (glseg.x2 - glseg.x1);
|
|
glseg.y2 = glseg.y1 + inter_x * (glseg.y2 - glseg.y1);
|
|
glseg.fracright = inter_x;
|
|
|
|
zbottom[1] = ztop[1] = inter_y;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Do some tweaks with the texture coordinates to reduce visual glitches
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::CheckTexturePosition()
|
|
{
|
|
float sub;
|
|
|
|
if (texture->isHardwareCanvas()) return;
|
|
|
|
// clamp texture coordinates to a reasonable range.
|
|
// Extremely large values can cause visual problems
|
|
if (tcs[UPLFT].v < tcs[LOLFT].v || tcs[UPRGT].v < tcs[LORGT].v)
|
|
{
|
|
if (tcs[UPLFT].v < tcs[UPRGT].v)
|
|
{
|
|
sub = float(xs_FloorToInt(tcs[UPLFT].v));
|
|
}
|
|
else
|
|
{
|
|
sub = float(xs_FloorToInt(tcs[UPRGT].v));
|
|
}
|
|
tcs[UPLFT].v -= sub;
|
|
tcs[UPRGT].v -= sub;
|
|
tcs[LOLFT].v -= sub;
|
|
tcs[LORGT].v -= sub;
|
|
}
|
|
else
|
|
{
|
|
if (tcs[LOLFT].v < tcs[LORGT].v)
|
|
{
|
|
sub = float(xs_FloorToInt(tcs[LOLFT].v));
|
|
}
|
|
else
|
|
{
|
|
sub = float(xs_FloorToInt(tcs[LORGT].v));
|
|
}
|
|
tcs[UPLFT].v -= sub;
|
|
tcs[UPRGT].v -= sub;
|
|
tcs[LOLFT].v -= sub;
|
|
tcs[LORGT].v -= sub;
|
|
}
|
|
if (tcs[UPLFT].u >= 0.f && tcs[UPRGT].u >= 0.f && tcs[LOLFT].u >= 0.f && tcs[LORGT].u >= 0.f &&
|
|
tcs[UPLFT].u <= 1.f && tcs[UPRGT].u <= 1.f && tcs[LOLFT].u <= 1.f && tcs[LORGT].u <= 1.f)
|
|
{
|
|
flags |= HWF_CLAMPX;
|
|
}
|
|
|
|
if (tcs[UPLFT].v >= 0.f && tcs[UPRGT].v >= 0.f && tcs[LOLFT].v >= 0.f && tcs[LORGT].v >= 0.f &&
|
|
tcs[UPLFT].v <= 1.f && tcs[UPRGT].v <= 1.f && tcs[LOLFT].v <= 1.f && tcs[LORGT].v <= 1.f)
|
|
{
|
|
flags |= HWF_CLAMPY;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// Common part of wall drawers
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::DoTexture(HWDrawInfo* di, walltype* wal, walltype* refwall, float refheight, float topleft, float topright, float bottomleft, float bottomright)
|
|
{
|
|
auto glsave = glseg;
|
|
SetWallCoordinates(wal, topleft, topright, bottomleft, bottomright);
|
|
|
|
bool xflipped = (wal->cstat & CSTAT_WALL_XFLIP);
|
|
float leftdist = xflipped ? 1.f - glseg.fracleft : glseg.fracleft;
|
|
float rightdist = xflipped ? 1.f - glseg.fracright : glseg.fracright;
|
|
|
|
float tw = texture->GetDisplayWidth();
|
|
float th = texture->GetDisplayHeight();
|
|
int pow2size = 1 << sizeToBits(th);
|
|
if (pow2size < th) pow2size *= 2;
|
|
float ypanning = refwall->ypan_ ? pow2size * refwall->ypan_ / (256.0f * th) : 0;
|
|
|
|
tcs[LOLFT].u = tcs[UPLFT].u = ((leftdist * 8.f * wal->xrepeat) + refwall->xpan_) / tw;
|
|
tcs[LORGT].u = tcs[UPRGT].u = ((rightdist * 8.f * wal->xrepeat) + refwall->xpan_) / tw;
|
|
|
|
auto setv = [=](float hl, float hr, float frac) -> float
|
|
{
|
|
float h = hl + (hr - hl) * frac;
|
|
h = (-(float)(refheight + (h * 256)) / ((th * 2048.0f) / (float)(wal->yrepeat))) + ypanning;
|
|
if (wal->cstat & CSTAT_WALL_YFLIP) h = -h;
|
|
return h;
|
|
};
|
|
|
|
tcs[UPLFT].v = setv(topleft, topright, glseg.fracleft);
|
|
tcs[LOLFT].v = setv(bottomleft, bottomright, glseg.fracleft);
|
|
tcs[UPRGT].v = setv(topleft, topright, glseg.fracright);
|
|
tcs[LORGT].v = setv(bottomleft, bottomright, glseg.fracright);
|
|
if (th == pow2size) CheckTexturePosition(); // for NPOT textures this adjustment can break things.
|
|
bool trans = type == RENDERWALL_M2S && (wal->cstat & CSTAT_WALL_TRANSLUCENT);
|
|
if (trans)
|
|
{
|
|
RenderStyle = GetRenderStyle(0, !!(wal->cstat & CSTAT_WALL_TRANS_FLIP));
|
|
alpha = GetAlphaFromBlend((wal->cstat & CSTAT_WALL_TRANS_FLIP) ? DAMETH_TRANS2 : DAMETH_TRANS1, 0);
|
|
}
|
|
PutWall(di, trans);
|
|
flags = 0;
|
|
glseg = glsave;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Handle one sided walls
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::DoOneSidedTexture(HWDrawInfo* di, walltype* wal, sectortype* frontsector, sectortype* backsector,
|
|
float topleft, float topright, float bottomleft, float bottomright)
|
|
{
|
|
// get the alignment reference position.
|
|
int refheight;
|
|
|
|
if ((wal->cstat & CSTAT_WALL_1WAY) && backsector)
|
|
{
|
|
if ((!(wal->cstat & CSTAT_WALL_BOTTOM_SWAP) && (wal->cstat & CSTAT_WALL_1WAY)) ||
|
|
((wal->cstat & CSTAT_WALL_BOTTOM_SWAP) && (wall[wal->nextwall].cstat & CSTAT_WALL_ALIGN_BOTTOM)))
|
|
refheight = frontsector->ceilingz;
|
|
else
|
|
refheight = backsector->floorz;
|
|
}
|
|
else
|
|
{
|
|
refheight = (wal->cstat & CSTAT_WALL_ALIGN_BOTTOM) ? frontsector->floorz : frontsector->ceilingz;
|
|
}
|
|
|
|
type = RENDERWALL_M1S;
|
|
DoTexture(di, wal, wal, refheight, topleft, topright, bottomleft, bottomright);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::DoUpperTexture(HWDrawInfo* di, walltype* wal, sectortype* frontsector, sectortype* backsector,
|
|
float topleft, float topright, float bottomleft, float bottomright)
|
|
{
|
|
// get the alignment reference position.
|
|
int refheight = (wal->cstat & CSTAT_WALL_ALIGN_BOTTOM) ? frontsector->ceilingz : backsector->ceilingz;
|
|
|
|
type = RENDERWALL_TOP;
|
|
DoTexture(di, wal, wal, refheight, topleft, topright, bottomleft, bottomright);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::DoLowerTexture(HWDrawInfo* di, walltype* wal, sectortype* frontsector, sectortype* backsector,
|
|
float topleft, float topright, float bottomleft, float bottomright)
|
|
{
|
|
// get the alignment reference position.
|
|
int refheight;
|
|
auto refwall = (wal->cstat & CSTAT_WALL_BOTTOM_SWAP) ? &wall[wal->nextwall] : wal;
|
|
refheight = (refwall->cstat & CSTAT_WALL_ALIGN_BOTTOM) ? frontsector->ceilingz : backsector->floorz;
|
|
|
|
shade = clamp(refwall->shade, 0, numshades - 1);
|
|
palette = refwall->pal;
|
|
type = RENDERWALL_BOTTOM;
|
|
DoTexture(di, wal, refwall, refheight, topleft, topright, bottomleft, bottomright);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void HWWall::DoMidTexture(HWDrawInfo* di, walltype* wal,
|
|
sectortype* front, sectortype* back,
|
|
float fch1, float fch2, float ffh1, float ffh2,
|
|
float bch1, float bch2, float bfh1, float bfh2)
|
|
{
|
|
float topleft,bottomleft,topright,bottomright;
|
|
int refheight;
|
|
|
|
const int swapit = (wal->cstat & CSTAT_WALL_ALIGN_BOTTOM);
|
|
|
|
if (wal->cstat & CSTAT_WALL_1WAY)
|
|
{
|
|
// 1-sided wall
|
|
refheight = swapit ? front->ceilingz : back->ceilingz;
|
|
}
|
|
else
|
|
{
|
|
// masked wall
|
|
if (swapit)
|
|
refheight = min(front->floorz, back->floorz);
|
|
else
|
|
refheight = max(front->ceilingz, back->ceilingz);
|
|
}
|
|
|
|
topleft = std::min(bch1,fch1);
|
|
topright = std::min(bch2,fch2);
|
|
bottomleft = std::max(bfh1,ffh1);
|
|
bottomright = std::max(bfh2,ffh2);
|
|
if (topleft<=bottomleft && topright<=bottomright) return;
|
|
type = seg->cstat & CSTAT_WALL_1WAY ? RENDERWALL_M1S : RENDERWALL_M2S;
|
|
|
|
// todo: transparency.
|
|
|
|
DoTexture(di, wal, wal, refheight, topleft, topright, bottomleft, bottomright);
|
|
RenderStyle = STYLE_Translucent;
|
|
alpha = 1.f;
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
void HWWall::Process(HWDrawInfo* di, walltype* wal, sectortype* frontsector, sectortype* backsector)
|
|
{
|
|
auto backwall = wal->nextwall >= 0 && wal->nextwall < numwalls ? &wall[wal->nextwall] : nullptr;
|
|
auto p2wall = &wall[wal->point2];
|
|
|
|
float fch1;
|
|
float ffh1;
|
|
float fch2;
|
|
float ffh2;
|
|
|
|
FVector2 v1(WallStartX(wal), WallStartY(wal));
|
|
FVector2 v2(WallEndX(wal), WallEndY(wal));
|
|
|
|
PlanesAtPoint(frontsector, wal->x, wal->y, &fch1, &ffh1);
|
|
PlanesAtPoint(frontsector, p2wall->x, p2wall->y, &fch2, &ffh2);
|
|
|
|
|
|
#ifdef _DEBUG
|
|
if (wal - wall == 843)
|
|
{
|
|
int a = 0;
|
|
}
|
|
#endif
|
|
|
|
this->seg = wal;
|
|
this->frontsector = frontsector;
|
|
this->backsector = backsector;
|
|
sprite = nullptr;
|
|
vertindex = 0;
|
|
vertcount = 0;
|
|
|
|
glseg.x1 = v1.X;
|
|
glseg.y1 = v1.Y;
|
|
glseg.x2 = v2.X;
|
|
glseg.y2 = v2.Y;
|
|
glseg.fracleft = 0;
|
|
glseg.fracright = 1;
|
|
flags = 0;
|
|
dynlightindex = -1;
|
|
shade = clamp(wal->shade, 0, numshades - 1);
|
|
palette = wal->pal;
|
|
fade = lookups.getFade(frontsector->floorpal); // fog is per sector.
|
|
visibility = sectorVisibility(frontsector);
|
|
|
|
alpha = 1.0f;
|
|
RenderStyle = STYLE_Translucent;
|
|
texture = NULL;
|
|
|
|
/*
|
|
if (wal->linedef->special == Line_Horizon)
|
|
{
|
|
SkyNormal(di, frontsector, v1, v2);
|
|
DoHorizon(di, wal, frontsector, v1, v2);
|
|
return;
|
|
}
|
|
*/
|
|
|
|
bool isportal = false;// wal->linedef->isVisualPortal() && wal->sidedef == wal->linedef->sidedef[0];
|
|
|
|
if (seg->portalflags)
|
|
{
|
|
int ptype = -1;
|
|
if (seg->portalflags == PORTAL_WALL_MIRROR) ptype = PORTALTYPE_MIRROR;
|
|
else if (seg->portalflags == PORTAL_WALL_VIEW) ptype = PORTALTYPE_LINETOLINE;
|
|
else if (seg->portalflags == PORTAL_WALL_TO_SPRITE) ptype = PORTALTYPE_LINETOSPRITE;
|
|
if (ptype != -1)
|
|
{
|
|
ztop[0] = fch1;
|
|
ztop[1] = fch2;
|
|
zbottom[0] = ffh1;
|
|
zbottom[1] = ffh2;
|
|
PutPortal(di, ptype, -1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
if (!backsector || !backwall)
|
|
{
|
|
// sector's sky
|
|
SkyNormal(di, frontsector, v1, v2, fch1, fch2, ffh1, ffh2);
|
|
|
|
// normal texture
|
|
|
|
int tilenum = ((wal->cstat & CSTAT_WALL_1WAY) && wal->nextwall != -1) ? wal->overpicnum : wal->picnum;
|
|
setgotpic(tilenum);
|
|
tileUpdatePicnum(&tilenum, int(wal-wall) + 16384, wal->cstat);
|
|
texture = tileGetTexture(tilenum);
|
|
if (texture && texture->isValid())
|
|
{
|
|
DoOneSidedTexture(di, wal, frontsector, backsector, fch1, fch2, ffh1, ffh2);
|
|
}
|
|
}
|
|
else // two sided
|
|
{
|
|
float bfh1;
|
|
float bfh2;
|
|
float bch1;
|
|
float bch2;
|
|
PlanesAtPoint(backsector, wal->x, wal->y, &bch1, &bfh1);
|
|
PlanesAtPoint(backsector, p2wall->x, p2wall->y, &bch2, &bfh2);
|
|
|
|
float zalign = 0.f;
|
|
|
|
if (fch1 > ffh1 || fch2 > ffh2)
|
|
{
|
|
SkyTop(di, wal, frontsector, backsector, v1, v2, fch1, fch2);
|
|
SkyBottom(di, wal, frontsector, backsector, v1, v2, ffh1, ffh2);
|
|
}
|
|
|
|
// upper texture
|
|
if (!(frontsector->ceilingstat & backsector->ceilingstat & CSTAT_SECTOR_SKY))
|
|
{
|
|
float bch1a = bch1;
|
|
float bch2a = bch2;
|
|
if (ffh1 > bch1 && ffh2 > bch2)
|
|
{
|
|
// the back sector's floor obstructs part of this wall
|
|
bch2a = ffh2;
|
|
bch1a = ffh1;
|
|
}
|
|
|
|
if (bch1a < fch1 || bch2a < fch2)
|
|
{
|
|
int tilenum = wal->picnum;
|
|
setgotpic(tilenum);
|
|
tileUpdatePicnum(&tilenum, int(wal - wall) + 16384, wal->cstat);
|
|
texture = tileGetTexture(tilenum);
|
|
if (texture && texture->isValid())
|
|
{
|
|
DoUpperTexture(di, wal, frontsector, backsector, fch1, fch2, bch1a, bch2a);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (wal->cstat & (CSTAT_WALL_MASKED | CSTAT_WALL_1WAY))
|
|
{
|
|
int tilenum = wal->overpicnum;
|
|
setgotpic(tilenum);
|
|
tileUpdatePicnum(&tilenum, int(wal - wall) + 16384, wal->cstat);
|
|
texture = tileGetTexture(tilenum);
|
|
if (texture && texture->isValid())
|
|
{
|
|
DoMidTexture(di, wal, frontsector, backsector, fch1, fch2, ffh1, ffh2, bch1, bch2, bfh1, bfh2);
|
|
}
|
|
}
|
|
|
|
// lower texture
|
|
if (!(frontsector->floorstat & backsector->floorstat & CSTAT_SECTOR_SKY))
|
|
{
|
|
if (fch1 < bfh1 && fch2 < bfh2)
|
|
{
|
|
// the back sector's ceiling obstructs part of this wall.
|
|
bfh1 = fch1;
|
|
bfh2 = fch2;
|
|
}
|
|
|
|
if (bfh1 > ffh1 || bfh2 > ffh2)
|
|
{
|
|
auto w = (wal->cstat & CSTAT_WALL_BOTTOM_SWAP) ? backwall : wal;
|
|
int tilenum = w->picnum;
|
|
setgotpic(tilenum);
|
|
tileUpdatePicnum(&tilenum, int(wal - wall) + 16384, w->cstat);
|
|
texture = tileGetTexture(tilenum);
|
|
if (texture && texture->isValid())
|
|
{
|
|
DoLowerTexture(di, wal, frontsector, backsector, bfh1, bfh2, ffh1, ffh2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void HWWall::ProcessWallSprite(HWDrawInfo* di, spritetype* spr, sectortype* sector)
|
|
{
|
|
auto tex = tileGetTexture(spr->picnum);
|
|
if (!tex || !tex->isValid()) return;
|
|
|
|
seg = nullptr;
|
|
sprite = spr;
|
|
vec2_t pos[2];
|
|
int sprz = spr->pos.z;
|
|
|
|
GetWallSpritePosition(spr, spr->pos.vec2, pos, true);
|
|
glseg.x1 = pos[0].x * (1 / 16.f);
|
|
glseg.y1 = pos[0].y * (1 / -16.f);
|
|
glseg.x2 = pos[1].x * (1 / 16.f);
|
|
glseg.y2 = pos[1].y * (1 / -16.f);
|
|
|
|
if (spr->cstat & CSTAT_SPRITE_ONE_SIDED)
|
|
{
|
|
if (PointOnLineSide(di->Viewpoint.Pos.X, di->Viewpoint.Pos.Y, glseg.x1, glseg.y1, glseg.x2 - glseg.x1, glseg.y2 - glseg.y1) <= 0)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
vertindex = 0;
|
|
vertcount = 0;
|
|
type = RENDERWALL_M2S;
|
|
frontsector = sector;
|
|
backsector = sector;
|
|
texture = tex;
|
|
|
|
flags = 0;
|
|
dynlightindex = -1;
|
|
shade = clamp(spr->shade, 0, numshades - 1);
|
|
palette = spr->pal;
|
|
fade = lookups.getFade(sector->floorpal); // fog is per sector.
|
|
visibility = sectorVisibility(sector);
|
|
|
|
bool trans = (sprite->cstat & CSTAT_SPRITE_TRANSLUCENT);
|
|
if (trans)
|
|
{
|
|
RenderStyle = GetRenderStyle(0, !!(sprite->cstat & CSTAT_SPRITE_TRANSLUCENT_INVERT));
|
|
alpha = GetAlphaFromBlend((sprite->cstat & CSTAT_SPRITE_TRANSLUCENT_INVERT) ? DAMETH_TRANS2 : DAMETH_TRANS1, 0);
|
|
}
|
|
else
|
|
{
|
|
RenderStyle = LegacyRenderStyles[STYLE_Translucent];
|
|
alpha = 1.f;
|
|
}
|
|
|
|
|
|
int height, topofs;
|
|
if (hw_hightile && TileFiles.tiledata[spr->picnum].hiofs.xsize)
|
|
{
|
|
height = TileFiles.tiledata[spr->picnum].hiofs.ysize;
|
|
topofs = (TileFiles.tiledata[spr->picnum].hiofs.yoffs + spr->yoffset);
|
|
}
|
|
else
|
|
{
|
|
height = (int)tex->GetDisplayHeight();
|
|
topofs = ((int)tex->GetDisplayTopOffset() + spr->yoffset);
|
|
}
|
|
|
|
if (spr->cstat & CSTAT_SPRITE_YFLIP)
|
|
topofs = -topofs;
|
|
|
|
sprz -= ((topofs * spr->yrepeat) << 2);
|
|
|
|
if (spr->cstat & CSTAT_SPRITE_YCENTER)
|
|
{
|
|
sprz += ((height * spr->yrepeat) << 1);
|
|
if (height & 1) sprz += (spr->yrepeat << 1); // Odd yspans (taken from polymost as-is)
|
|
}
|
|
|
|
glseg.fracleft = 0;
|
|
glseg.fracright = 1;
|
|
tcs[LOLFT].u = tcs[UPLFT].u = (spr->cstat & CSTAT_SPRITE_XFLIP) ? 1.f : 0.f;
|
|
tcs[LORGT].u = tcs[UPRGT].u = (spr->cstat & CSTAT_SPRITE_XFLIP) ? 0.f : 1.f;
|
|
tcs[UPLFT].v = tcs[UPRGT].v = (spr->cstat & CSTAT_SPRITE_YFLIP) ? 1.f : 0.f;
|
|
tcs[LOLFT].v = tcs[LORGT].v = (spr->cstat & CSTAT_SPRITE_YFLIP) ? 0.f : 1.f;
|
|
|
|
zbottom[0] = zbottom[1] = (sprz) * (1 / -256.);
|
|
ztop[0] = ztop[1] = (sprz - ((height * spr->yrepeat) << 2)) * (1 / -256.);
|
|
|
|
|
|
// Clip sprites to ceilings/floors
|
|
float origz = ztop[0];
|
|
float polyh = (zbottom[0] - origz);
|
|
if (!(sector->ceilingstat & CSTAT_SECTOR_SKY))
|
|
{
|
|
float ceilingz = sector->ceilingz * (1 / -256.f);
|
|
if (ceilingz < ztop[0] && ceilingz > zbottom[0])
|
|
{
|
|
float newv = (ceilingz - origz) / polyh;
|
|
tcs[UPLFT].v = tcs[UPRGT].v = newv;
|
|
ztop[0] = ztop[1] = ceilingz;
|
|
}
|
|
}
|
|
if (!(sector->floorstat & CSTAT_SECTOR_SKY))
|
|
{
|
|
float floorz = sector->floorz * (1 / -256.f);
|
|
if (floorz < ztop[0] && floorz > zbottom[0])
|
|
{
|
|
float newv = (floorz - origz) / polyh;
|
|
tcs[LOLFT].v = tcs[LORGT].v = newv;
|
|
zbottom[0] = zbottom[1] = floorz;
|
|
}
|
|
}
|
|
PutWall(di, trans);
|
|
} |