OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

- start of light buffer implementation so that we don't have to use uniform arrays which appear to be broken on AMD.

Browse source
This commit is contained in:
Christoph Oelckers 2014-07-31 00:44:22 +02:00
commit 1ec58011d2
6 changed files with 192 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

153
src/gl/dynlights/gl_lightbuffer.cpp Normal file
View file

@ -0,0 +1,153 @@
/*
** gl_lightbuffer.cpp
** Buffer data maintenance for dynamic lights
**
**---------------------------------------------------------------------------
** Copyright 2014 Christoph Oelckers
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
** 4. When not used as part of GZDoom or a GZDoom derivative, this code will be
** covered by the terms of the GNU Lesser General Public License as published
** by the Free Software Foundation; either version 2.1 of the License, or (at
** your option) any later version.
** 5. Full disclosure of the entire project's source code, except for third
** party libraries is mandatory. (NOTE: This clause is non-negotiable!)
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
#include "gl/system/gl_system.h"
#include "gl/dynlights/gl_lightbuffer.h"
#include "gl/dynlights/gl_dynlight.h"
#include "gl/system/gl_interface.h"
static const int LIGHTBUF_BINDINGPOINT = 1;
FLightBuffer::FLightBuffer()
{
if (gl.flags & RFL_SHADER_STORAGE_BUFFER)
{
mBufferType = GL_SHADER_STORAGE_BUFFER;
mBufferSize = 80000; // 40000 lights per scene should be plenty. The largest I've ever seen was around 5000.
}
else
{
mBufferType = GL_UNIFORM_BUFFER;
mBufferSize = gl.maxuniformblock / 4 - 100; // we need to be a bit careful here so don't use the full buffer size
}
AddBuffer();
Clear();
}
FLightBuffer::~FLightBuffer()
{
glBindBuffer(mBufferType, 0);
for (unsigned int i = 0; i < mBufferIds.Size(); i++)
{
glDeleteBuffers(1, &mBufferIds[i]);
}
}
void FLightBuffer::AddBuffer()
{
unsigned int id;
glGenBuffers(1, &id);
mBufferIds.Push(id);
glBindBuffer(mBufferType, id);
unsigned int bytesize = mBufferSize * 8 * sizeof(float);
if (gl.flags & RFL_BUFFER_STORAGE)
{
glBufferStorage(mBufferType, bytesize, NULL, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
void *map = glMapBufferRange(mBufferType, 0, bytesize, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
mBufferPointers.Push((float*)map);
}
else
{
glBufferData(mBufferType, bytesize, NULL, GL_STREAM_DRAW);
}
}
void FLightBuffer::Clear()
{
mBufferNum = 0;
mIndex = 0;
mBufferArray.Clear();
mBufferStart.Clear();
}
void FLightBuffer::UploadLights(FDynLightData &data, unsigned int &buffernum, unsigned int &bufferindex)
{
int size0 = data.arrays[0].Size()/4;
int size1 = data.arrays[1].Size()/4;
int size2 = data.arrays[2].Size()/4;
int totalsize = size0 + size1 + size2 + 1;
if (totalsize == 0) return;
if (mIndex + totalsize > mBufferSize)
{
if (gl.flags & RFL_SHADER_STORAGE_BUFFER)
{
return; // we do not want multiple shader storage blocks. 40000 lights is too much already
}
else
{
mBufferNum++;
mBufferStart.Push(mIndex);
mIndex = 0;
if (mBufferIds.Size() <= mBufferNum) AddBuffer();
}
}
float *copyptr;
if (gl.flags & RFL_BUFFER_STORAGE)
{
copyptr = mBufferPointers[mBufferNum] + mIndex * 4;
}
else
{
unsigned int pos = mBufferArray.Reserve(totalsize * 4);
copyptr = &mBufferArray[pos];
}
float parmcnt[] = { mIndex + 1, mIndex + 1 + size0, mIndex + 1 + size0 + size1, mIndex + totalsize };
memcpy(&copyptr[0], parmcnt, 4 * sizeof(float));
memcpy(&copyptr[1], &data.arrays[0][0], 4 * size0*sizeof(float));
memcpy(&copyptr[1 + size0], &data.arrays[1][0], 4 * size1*sizeof(float));
memcpy(&copyptr[1 + size0 + size1], &data.arrays[2][0], 4 * size2*sizeof(float));
buffernum = mBufferNum;
bufferindex = mIndex;
mIndex += totalsize;
}
void FLightBuffer::Finish()
{
//glBindBufferBase(mBufferType, LIGHTBUF_BINDINGPOINT, mBufferIds[0]);
}