mirror of
https://github.com/ZDoom/qzdoom.git
synced 2024-12-16 15:31:30 +00:00
260 lines
8 KiB
C++
260 lines
8 KiB
C++
//
|
|
//---------------------------------------------------------------------------
|
|
// 1D dynamic shadow maps
|
|
// Copyright(C) 2017 Magnus Norddahl
|
|
// 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 3 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 "gl/system/gl_system.h"
|
|
#include "gl/shaders/gl_shader.h"
|
|
#include "gl/dynlights/gl_shadowmap.h"
|
|
#include "gl/dynlights/gl_dynlight.h"
|
|
#include "gl/system/gl_interface.h"
|
|
#include "gl/system/gl_debug.h"
|
|
#include "gl/system/gl_cvars.h"
|
|
#include "gl/renderer/gl_renderer.h"
|
|
#include "gl/renderer/gl_postprocessstate.h"
|
|
#include "gl/renderer/gl_renderbuffers.h"
|
|
#include "gl/shaders/gl_shadowmapshader.h"
|
|
#include "r_state.h"
|
|
#include "g_levellocals.h"
|
|
#include "stats.h"
|
|
|
|
/*
|
|
The 1D shadow maps are stored in a 1024x1024 texture as float depth values (R32F).
|
|
|
|
Each line in the texture is assigned to a single light. For example, to grab depth values for light 20
|
|
the fragment shader (main.fp) needs to sample from row 20. That is, the V texture coordinate needs
|
|
to be 20.5/1024.
|
|
|
|
mLightToShadowmap is a hash map storing which line each ADynamicLight is assigned to. The public
|
|
ShadowMapIndex function allows the main rendering to find the index and upload that along with the
|
|
normal light data. From there, the main.fp shader can sample from the shadow map texture, which
|
|
is currently always bound to texture unit 16.
|
|
|
|
The texel row for each light is split into four parts. One for each direction, like a cube texture,
|
|
but then only in 2D where this reduces itself to a square. When main.fp samples from the shadow map
|
|
it first decides in which direction the fragment is (relative to the light), like cubemap sampling does
|
|
for 3D, but once again just for the 2D case.
|
|
|
|
Texels 0-255 is Y positive, 256-511 is X positive, 512-767 is Y negative and 768-1023 is X negative.
|
|
|
|
Generating the shadow map itself is done by FShadowMap::Update(). The shadow map texture's FBO is
|
|
bound and then a screen quad is drawn to make a fragment shader cover all texels. For each fragment
|
|
it shoots a ray and collects the distance to what it hit.
|
|
|
|
The shadowmap.fp shader knows which light and texel it is processing by mapping gl_FragCoord.y back
|
|
to the light index, and it knows which direction to ray trace by looking at gl_FragCoord.x. For
|
|
example, if gl_FragCoord.y is 20.5, then it knows its processing light 20, and if gl_FragCoord.x is
|
|
127.5, then it knows we are shooting straight ahead for the Y positive direction.
|
|
|
|
Ray testing is done by uploading two GPU storage buffers - one holding AABB tree nodes, and one with
|
|
the line segments at the leaf nodes of the tree. The fragment shader then performs a test same way
|
|
as on the CPU, except everything uses indexes as pointers are not allowed in GLSL.
|
|
*/
|
|
|
|
namespace
|
|
{
|
|
cycle_t UpdateCycles;
|
|
int LightsProcessed;
|
|
int LightsShadowmapped;
|
|
}
|
|
|
|
ADD_STAT(shadowmap)
|
|
{
|
|
FString out;
|
|
out.Format("upload=%04.2f ms lights=%d shadowmapped=%d", UpdateCycles.TimeMS(), LightsProcessed, LightsShadowmapped);
|
|
return out;
|
|
}
|
|
|
|
CUSTOM_CVAR(Int, gl_shadowmap_quality, 512, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
|
{
|
|
switch (self)
|
|
{
|
|
case 128:
|
|
case 256:
|
|
case 512:
|
|
case 1024:
|
|
break;
|
|
default:
|
|
self = 128;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void FShadowMap::Update()
|
|
{
|
|
UpdateCycles.Reset();
|
|
LightsProcessed = 0;
|
|
LightsShadowmapped = 0;
|
|
|
|
if (!IsEnabled())
|
|
return;
|
|
|
|
UpdateCycles.Clock();
|
|
|
|
UploadAABBTree();
|
|
UploadLights();
|
|
|
|
FGLDebug::PushGroup("ShadowMap");
|
|
FGLPostProcessState savedState;
|
|
|
|
GLRenderer->mBuffers->BindShadowMapFB();
|
|
|
|
GLRenderer->mShadowMapShader->Bind();
|
|
GLRenderer->mShadowMapShader->ShadowmapQuality.Set(gl_shadowmap_quality);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, mLightList);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, mNodesBuffer);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, mLinesBuffer);
|
|
|
|
glViewport(0, 0, gl_shadowmap_quality, 1024);
|
|
GLRenderer->RenderScreenQuad();
|
|
|
|
const auto &viewport = GLRenderer->mScreenViewport;
|
|
glViewport(viewport.left, viewport.top, viewport.width, viewport.height);
|
|
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, 0);
|
|
|
|
GLRenderer->mBuffers->BindShadowMapTexture(16);
|
|
|
|
FGLDebug::PopGroup();
|
|
|
|
UpdateCycles.Unclock();
|
|
}
|
|
|
|
bool FShadowMap::ShadowTest(ADynamicLight *light, const DVector3 &pos)
|
|
{
|
|
if (light->shadowmapped && light->radius > 0.0 && IsEnabled() && mAABBTree)
|
|
return mAABBTree->RayTest(light->Pos(), pos) >= 1.0f;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
bool FShadowMap::IsEnabled() const
|
|
{
|
|
return gl_light_shadowmap && !!(gl.flags & RFL_SHADER_STORAGE_BUFFER);
|
|
}
|
|
|
|
int FShadowMap::ShadowMapIndex(ADynamicLight *light)
|
|
{
|
|
if (IsEnabled())
|
|
{
|
|
auto val = mLightToShadowmap.CheckKey(light);
|
|
if (val != nullptr) return *val;
|
|
}
|
|
return 1024;
|
|
}
|
|
|
|
void FShadowMap::UploadLights()
|
|
{
|
|
if (mLights.Size() != 1024 * 4) mLights.Resize(1024 * 4);
|
|
int lightindex = 0;
|
|
mLightToShadowmap.Clear(mLightToShadowmap.CountUsed() * 2); // To do: allow clearing a TMap while building up a reserve
|
|
|
|
// Todo: this should go through the blockmap in a spiral pattern around the player so that closer lights are preferred.
|
|
TThinkerIterator<ADynamicLight> it(STAT_DLIGHT);
|
|
while (auto light = it.Next())
|
|
{
|
|
LightsProcessed++;
|
|
if (light->shadowmapped)
|
|
{
|
|
LightsShadowmapped++;
|
|
|
|
mLightToShadowmap[light] = lightindex >> 2;
|
|
|
|
mLights[lightindex] = light->X();
|
|
mLights[lightindex+1] = light->Y();
|
|
mLights[lightindex+2] = light->Z();
|
|
mLights[lightindex+3] = light->GetRadius();
|
|
lightindex += 4;
|
|
|
|
if (lightindex == 1024*4) // Only 1024 lights for now
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
for (; lightindex < 1024 * 4; lightindex++)
|
|
{
|
|
mLights[lightindex] = 0;
|
|
}
|
|
|
|
if (mLightList == 0)
|
|
glGenBuffers(1, (GLuint*)&mLightList);
|
|
|
|
int oldBinding = 0;
|
|
glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, &oldBinding);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mLightList);
|
|
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float) * mLights.Size(), &mLights[0], GL_STATIC_DRAW);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, oldBinding);
|
|
}
|
|
|
|
void FShadowMap::UploadAABBTree()
|
|
{
|
|
// Just comparing the level info is not enough. If two MAPINFO-less levels get played after each other,
|
|
// they can both refer to the same default level info.
|
|
if (level.info != mLastLevel && (level.nodes.Size() != mLastNumNodes || level.segs.Size() != mLastNumSegs))
|
|
Clear();
|
|
|
|
if (mAABBTree)
|
|
return;
|
|
|
|
mAABBTree.reset(new LevelAABBTree());
|
|
|
|
int oldBinding = 0;
|
|
glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, &oldBinding);
|
|
|
|
glGenBuffers(1, (GLuint*)&mNodesBuffer);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mNodesBuffer);
|
|
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(AABBTreeNode) * mAABBTree->nodes.Size(), &mAABBTree->nodes[0], GL_STATIC_DRAW);
|
|
|
|
glGenBuffers(1, (GLuint*)&mLinesBuffer);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mLinesBuffer);
|
|
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(AABBTreeLine) * mAABBTree->lines.Size(), &mAABBTree->lines[0], GL_STATIC_DRAW);
|
|
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, oldBinding);
|
|
}
|
|
|
|
void FShadowMap::Clear()
|
|
{
|
|
if (mLightList != 0)
|
|
{
|
|
glDeleteBuffers(1, (GLuint*)&mLightList);
|
|
mLightList = 0;
|
|
}
|
|
|
|
if (mNodesBuffer != 0)
|
|
{
|
|
glDeleteBuffers(1, (GLuint*)&mNodesBuffer);
|
|
mNodesBuffer = 0;
|
|
}
|
|
|
|
if (mLinesBuffer != 0)
|
|
{
|
|
glDeleteBuffers(1, (GLuint*)&mLinesBuffer);
|
|
mLinesBuffer = 0;
|
|
}
|
|
|
|
mAABBTree.reset();
|
|
|
|
mLastLevel = level.info;
|
|
mLastNumNodes = level.nodes.Size();
|
|
mLastNumSegs = level.segs.Size();
|
|
}
|