458 lines
14 KiB
C++
458 lines
14 KiB
C++
/*
|
|
Copyright (c) 2013 yvt
|
|
|
|
This file is part of OpenSpades.
|
|
|
|
OpenSpades is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
OpenSpades 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenSpades. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
#include "GLDepthOfFieldFilter.h"
|
|
#include "IGLDevice.h"
|
|
#include "../Core/Math.h"
|
|
#include <vector>
|
|
#include "GLQuadRenderer.h"
|
|
#include "GLProgram.h"
|
|
#include "GLProgramAttribute.h"
|
|
#include "GLProgramUniform.h"
|
|
#include "GLRenderer.h"
|
|
#include "../Core/Debug.h"
|
|
#include "GLProfiler.h"
|
|
#include "../Core/Settings.h"
|
|
|
|
SPADES_SETTING(r_depthOfField, "");
|
|
|
|
namespace spades {
|
|
namespace draw {
|
|
GLDepthOfFieldFilter::GLDepthOfFieldFilter(GLRenderer *renderer):
|
|
renderer(renderer){
|
|
gaussProgram = renderer->RegisterProgram("Shaders/PostFilters/Gauss1D.program");
|
|
blurProgram = renderer->RegisterProgram("Shaders/PostFilters/DoFBlur.program");
|
|
cocGen = renderer->RegisterProgram("Shaders/PostFilters/DoFCoCGen.program");
|
|
cocMix = renderer->RegisterProgram("Shaders/PostFilters/DoFCoCMix.program");
|
|
gammaMix = renderer->RegisterProgram("Shaders/PostFilters/GammaMix.program");
|
|
finalMix = renderer->RegisterProgram("Shaders/PostFilters/DoFMix.program");
|
|
passthrough = renderer->RegisterProgram("Shaders/PostFilters/PassThrough.program");
|
|
}
|
|
|
|
GLColorBuffer GLDepthOfFieldFilter::BlurCoC(GLColorBuffer buffer,
|
|
float spread) {
|
|
SPADES_MARK_FUNCTION();
|
|
// do gaussian blur
|
|
GLProgram *program = gaussProgram;
|
|
IGLDevice *dev = renderer->GetGLDevice();
|
|
GLQuadRenderer qr(dev);
|
|
int w = buffer.GetWidth();
|
|
int h = buffer.GetHeight();
|
|
|
|
static GLProgramAttribute blur_positionAttribute("positionAttribute");
|
|
static GLProgramUniform blur_textureUniform("texture");
|
|
static GLProgramUniform blur_unitShift("unitShift");
|
|
program->Use();
|
|
blur_positionAttribute(program);
|
|
blur_textureUniform(program);
|
|
blur_unitShift(program);
|
|
blur_textureUniform.SetValue(0);
|
|
|
|
dev->ActiveTexture(0);
|
|
qr.SetCoordAttributeIndex(blur_positionAttribute());
|
|
dev->Enable(IGLDevice::Blend, false);
|
|
|
|
// x-direction
|
|
GLColorBuffer buf2 = renderer->GetFramebufferManager()->CreateBufferHandle(w, h, 1);
|
|
dev->BindTexture(IGLDevice::Texture2D, buffer.GetTexture());
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, buf2.GetFramebuffer());
|
|
blur_unitShift.SetValue(spread / (float)w, 0.f);
|
|
qr.Draw();
|
|
buffer.Release();
|
|
|
|
// y-direction
|
|
GLColorBuffer buf3 = renderer->GetFramebufferManager()->CreateBufferHandle(w, h, 1);
|
|
dev->BindTexture(IGLDevice::Texture2D, buf2.GetTexture());
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, buf3.GetFramebuffer());
|
|
blur_unitShift.SetValue(0.f, spread / (float)h);
|
|
qr.Draw();
|
|
buf2.Release();
|
|
|
|
return buf3;
|
|
}
|
|
|
|
GLColorBuffer GLDepthOfFieldFilter::GenerateCoC(float blurDepthRange, float vignetteBlur, float globalBlur) {
|
|
SPADES_MARK_FUNCTION();
|
|
IGLDevice *dev = renderer->GetGLDevice();
|
|
GLQuadRenderer qr(dev);
|
|
|
|
int w = dev->ScreenWidth();
|
|
int h = dev->ScreenHeight();
|
|
int w2 = (w + 3) / 4;
|
|
int h2 = (h + 3) / 4;
|
|
|
|
|
|
GLColorBuffer coc = renderer->GetFramebufferManager()->CreateBufferHandle(w2, h2, 1);
|
|
|
|
{
|
|
static GLProgramAttribute positionAttribute("positionAttribute");
|
|
static GLProgramUniform depthTexture("depthTexture");
|
|
static GLProgramUniform zNearFar("zNearFar");
|
|
static GLProgramUniform pixelShift("pixelShift");
|
|
static GLProgramUniform depthScale("depthScale");
|
|
static GLProgramUniform maxVignetteBlur("maxVignetteBlur");
|
|
static GLProgramUniform vignetteScale("vignetteScale");
|
|
static GLProgramUniform globalBlurUniform("globalBlur");
|
|
|
|
positionAttribute(cocGen);
|
|
depthTexture(cocGen);
|
|
zNearFar(cocGen);
|
|
pixelShift(cocGen);
|
|
depthScale(cocGen);
|
|
maxVignetteBlur(cocGen);
|
|
vignetteScale(cocGen);
|
|
globalBlurUniform(cocGen);
|
|
|
|
cocGen->Use();
|
|
|
|
depthTexture.SetValue(0);
|
|
|
|
const client::SceneDefinition& def = renderer->GetSceneDef();
|
|
zNearFar.SetValue(def.zNear, def.zFar);
|
|
|
|
pixelShift.SetValue(1.f / (float)w,
|
|
1.f / (float)h);
|
|
|
|
depthScale.SetValue(1.f / blurDepthRange);
|
|
|
|
if(h > w){
|
|
vignetteScale.SetValue(2.f * (float)w / (float)h,
|
|
2.f);
|
|
}else{
|
|
vignetteScale.SetValue(2.f,
|
|
2.f * (float)h / (float)w);
|
|
}
|
|
maxVignetteBlur.SetValue(sinf(std::max(def.fovX, def.fovY) * .5f) * vignetteBlur);
|
|
globalBlurUniform.SetValue(globalBlur);
|
|
|
|
qr.SetCoordAttributeIndex(positionAttribute());
|
|
dev->BindTexture(IGLDevice::Texture2D, renderer->GetFramebufferManager()->GetDepthTexture());
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, coc.GetFramebuffer());
|
|
dev->Viewport(0, 0, w2, h2);
|
|
qr.Draw();
|
|
dev->BindTexture(IGLDevice::Texture2D, 0);
|
|
}
|
|
// make blurred CoC radius bitmap
|
|
GLColorBuffer cocBlur = BlurCoC(coc, 1.f);
|
|
|
|
// mix
|
|
|
|
GLColorBuffer coc2 = renderer->GetFramebufferManager()->CreateBufferHandle(w2, h2, 1);
|
|
|
|
{
|
|
static GLProgramAttribute positionAttribute("positionAttribute");
|
|
static GLProgramUniform cocTexture("cocTexture");
|
|
static GLProgramUniform cocBlurTexture("cocBlurTexture");
|
|
|
|
|
|
positionAttribute(cocMix);
|
|
cocTexture(cocMix);
|
|
cocBlurTexture(cocMix);
|
|
|
|
cocMix->Use();
|
|
|
|
cocBlurTexture.SetValue(1);
|
|
dev->ActiveTexture(1);
|
|
dev->BindTexture(IGLDevice::Texture2D, cocBlur.GetTexture());
|
|
|
|
cocTexture.SetValue(0);
|
|
dev->ActiveTexture(0);
|
|
dev->BindTexture(IGLDevice::Texture2D, coc.GetTexture());
|
|
|
|
qr.SetCoordAttributeIndex(positionAttribute());
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, coc2.GetFramebuffer());
|
|
dev->Viewport(0, 0, w2, h2);
|
|
qr.Draw();
|
|
dev->BindTexture(IGLDevice::Texture2D, 0);
|
|
}
|
|
|
|
coc2 = BlurCoC(coc2, .5f);
|
|
|
|
return coc2;
|
|
}
|
|
|
|
GLColorBuffer GLDepthOfFieldFilter::Blur(GLColorBuffer buffer,
|
|
|
|
GLColorBuffer coc,
|
|
Vector2 offset,
|
|
int divide) {
|
|
SPADES_MARK_FUNCTION();
|
|
// do gaussian blur
|
|
GLProgram *program = blurProgram;
|
|
IGLDevice *dev = renderer->GetGLDevice();
|
|
GLQuadRenderer qr(dev);
|
|
int w = buffer.GetWidth();
|
|
int h = buffer.GetHeight();
|
|
int w2 = w / divide;
|
|
int h2 = h / divide;
|
|
|
|
static GLProgramAttribute blur_positionAttribute("positionAttribute");
|
|
static GLProgramUniform blur_textureUniform("texture");
|
|
static GLProgramUniform blur_cocUniform("cocTexture");
|
|
static GLProgramUniform blur_offset("offset");
|
|
program->Use();
|
|
blur_positionAttribute(program);
|
|
blur_textureUniform(program);
|
|
blur_cocUniform(program);
|
|
blur_offset(program);
|
|
|
|
blur_cocUniform.SetValue(1);
|
|
dev->ActiveTexture(1);
|
|
dev->BindTexture(IGLDevice::Texture2D, coc.GetTexture());
|
|
|
|
blur_textureUniform.SetValue(0);
|
|
dev->ActiveTexture(0);
|
|
|
|
qr.SetCoordAttributeIndex(blur_positionAttribute());
|
|
|
|
// x-direction
|
|
float len = offset.GetLength();
|
|
float sX = 1.f / (float)w, sY = 1.f / (float)h;
|
|
while(len > .5f){
|
|
GLColorBuffer buf2 = renderer->GetFramebufferManager()->CreateBufferHandle(w2, h2, false);
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, buf2.GetFramebuffer());
|
|
dev->BindTexture(IGLDevice::Texture2D, buffer.GetTexture());
|
|
blur_offset.SetValue(offset.x * sX, offset.y * sY);
|
|
qr.Draw();
|
|
buffer = buf2;
|
|
|
|
offset *= .125f;
|
|
len *= .125f;
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
GLColorBuffer GLDepthOfFieldFilter::AddMix(GLColorBuffer buffer1, GLColorBuffer buffer2) {
|
|
SPADES_MARK_FUNCTION();
|
|
// do gaussian blur
|
|
GLProgram *program = gammaMix;
|
|
IGLDevice *dev = renderer->GetGLDevice();
|
|
GLQuadRenderer qr(dev);
|
|
int w = buffer1.GetWidth();
|
|
int h = buffer1.GetHeight();
|
|
|
|
static GLProgramAttribute blur_positionAttribute("positionAttribute");
|
|
static GLProgramUniform blur_textureUniform1("texture1");
|
|
static GLProgramUniform blur_textureUniform2("texture2");
|
|
static GLProgramUniform blur_unitShift("unitShift");
|
|
static GLProgramUniform blur_mix1("mix1");
|
|
static GLProgramUniform blur_mix2("mix2");
|
|
program->Use();
|
|
blur_positionAttribute(program);
|
|
|
|
blur_textureUniform1(program);
|
|
blur_textureUniform1.SetValue(1);
|
|
dev->ActiveTexture(1);
|
|
dev->BindTexture(IGLDevice::Texture2D, buffer1.GetTexture());
|
|
|
|
blur_textureUniform2(program);
|
|
blur_textureUniform2.SetValue(0);
|
|
dev->ActiveTexture(0);
|
|
dev->BindTexture(IGLDevice::Texture2D, buffer2.GetTexture());
|
|
|
|
blur_mix1(program);
|
|
blur_mix2(program);
|
|
|
|
blur_mix1.SetValue(.5f, .5f, .5f);
|
|
blur_mix2.SetValue(.5f, .5f, .5f);
|
|
|
|
qr.SetCoordAttributeIndex(blur_positionAttribute());
|
|
dev->Enable(IGLDevice::Blend, false);
|
|
|
|
// x-direction
|
|
GLColorBuffer buf2 = renderer->GetFramebufferManager()->CreateBufferHandle(w, h, false);
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, buf2.GetFramebuffer());
|
|
qr.Draw();
|
|
return buf2;
|
|
}
|
|
|
|
GLColorBuffer GLDepthOfFieldFilter::FinalMix(GLColorBuffer tex,
|
|
GLColorBuffer blur1,
|
|
GLColorBuffer blur2,
|
|
GLColorBuffer coc) {
|
|
SPADES_MARK_FUNCTION();
|
|
// do gaussian blur
|
|
GLProgram *program = finalMix;
|
|
IGLDevice *dev = renderer->GetGLDevice();
|
|
GLQuadRenderer qr(dev);
|
|
int w = tex.GetWidth();
|
|
int h = tex.GetHeight();
|
|
|
|
static GLProgramAttribute blur_positionAttribute("positionAttribute");
|
|
static GLProgramUniform blur_textureUniform1("texture");
|
|
static GLProgramUniform blur_textureUniform2("blurTexture1");
|
|
static GLProgramUniform blur_textureUniform3("blurTexture2");
|
|
static GLProgramUniform blur_textureUniform4("cocTexture");
|
|
program->Use();
|
|
blur_positionAttribute(program);
|
|
|
|
blur_textureUniform1(program);
|
|
blur_textureUniform1.SetValue(3);
|
|
dev->ActiveTexture(3);
|
|
dev->BindTexture(IGLDevice::Texture2D, tex.GetTexture());
|
|
|
|
blur_textureUniform2(program);
|
|
blur_textureUniform2.SetValue(2);
|
|
dev->ActiveTexture(2);
|
|
dev->BindTexture(IGLDevice::Texture2D, blur1.GetTexture());
|
|
|
|
blur_textureUniform3(program);
|
|
blur_textureUniform3.SetValue(1);
|
|
dev->ActiveTexture(1);
|
|
dev->BindTexture(IGLDevice::Texture2D, blur2.GetTexture());
|
|
|
|
blur_textureUniform4(program);
|
|
blur_textureUniform4.SetValue(0);
|
|
dev->ActiveTexture(0);
|
|
dev->BindTexture(IGLDevice::Texture2D, coc.GetTexture());
|
|
|
|
|
|
qr.SetCoordAttributeIndex(blur_positionAttribute());
|
|
dev->Enable(IGLDevice::Blend, false);
|
|
|
|
// x-direction
|
|
GLColorBuffer buf2 = renderer->GetFramebufferManager()->CreateBufferHandle(w, h, false);
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, buf2.GetFramebuffer());
|
|
qr.Draw();
|
|
return buf2;
|
|
}
|
|
|
|
GLColorBuffer GLDepthOfFieldFilter::UnderSample(GLColorBuffer tex) {
|
|
SPADES_MARK_FUNCTION();
|
|
// do gaussian blur
|
|
GLProgram *program = passthrough;
|
|
IGLDevice *dev = renderer->GetGLDevice();
|
|
GLQuadRenderer qr(dev);
|
|
int w = tex.GetWidth();
|
|
int h = tex.GetHeight();
|
|
|
|
static GLProgramAttribute blur_positionAttribute("positionAttribute");
|
|
static GLProgramUniform blur_textureUniform("texture");
|
|
static GLProgramUniform blur_colorUniform("colorUniform");
|
|
static GLProgramUniform blur_texCoordRangeUniform("texCoordRange");
|
|
program->Use();
|
|
blur_positionAttribute(program);
|
|
|
|
blur_textureUniform(program);
|
|
blur_textureUniform.SetValue(0);
|
|
dev->ActiveTexture(0);
|
|
dev->BindTexture(IGLDevice::Texture2D, tex.GetTexture());
|
|
|
|
blur_colorUniform(program);
|
|
blur_colorUniform.SetValue(1.f,1.f,1.f,1.f);
|
|
|
|
blur_texCoordRangeUniform(program);
|
|
blur_texCoordRangeUniform.SetValue(0.f, 0.f, 1.f, 1.f);
|
|
|
|
qr.SetCoordAttributeIndex(blur_positionAttribute());
|
|
dev->Enable(IGLDevice::Blend, false);
|
|
|
|
GLColorBuffer buf2 = renderer->GetFramebufferManager()->CreateBufferHandle(w/2, h/2, false);
|
|
dev->Viewport(0, 0, w/2, h/2);
|
|
dev->BindFramebuffer(IGLDevice::Framebuffer, buf2.GetFramebuffer());
|
|
qr.Draw();
|
|
return buf2;
|
|
}
|
|
|
|
|
|
GLColorBuffer GLDepthOfFieldFilter::Filter(GLColorBuffer input, float blurDepthRange, float vignetteBlur, float globalBlur) {
|
|
SPADES_MARK_FUNCTION();
|
|
|
|
IGLDevice *dev = renderer->GetGLDevice();
|
|
GLQuadRenderer qr(dev);
|
|
|
|
int w = dev->ScreenWidth();
|
|
int h = dev->ScreenHeight();
|
|
|
|
dev->Enable(IGLDevice::Blend, false);
|
|
|
|
GLColorBuffer coc;
|
|
|
|
globalBlur = std::min(globalBlur * 3.f, 1.f);
|
|
{
|
|
GLProfiler p(dev, "CoC Computation");
|
|
coc = GenerateCoC(blurDepthRange, vignetteBlur, globalBlur);
|
|
}
|
|
|
|
float maxCoc = (float)std::max(w, h) / 100.f;
|
|
float cos60 = cosf(static_cast<float>(M_PI) / 3.f);
|
|
float sin60 = sinf(static_cast<float>(M_PI) / 3.f);
|
|
|
|
maxCoc *= .7f + vignetteBlur * 0.5f;
|
|
maxCoc *= 1.f + 3.f * globalBlur;
|
|
|
|
// reduce resolution to make it faster
|
|
int divide = 1;
|
|
int siz = std::max(w, h);
|
|
GLColorBuffer lowbuf = input;
|
|
while(siz >= 768) {
|
|
divide <<= 1;
|
|
siz >>= 1;
|
|
lowbuf = UnderSample(lowbuf);
|
|
}
|
|
maxCoc /= (float)divide;
|
|
|
|
dev->Viewport(0, 0, w / divide, h / divide);
|
|
|
|
GLColorBuffer buf1, buf2;
|
|
{
|
|
GLProfiler p(dev, "Blur 1");
|
|
buf1 = Blur(lowbuf, coc,
|
|
MakeVector2(0.f, -1.f) * maxCoc);
|
|
}
|
|
{
|
|
GLProfiler p(dev, "Blur 2");
|
|
buf2 = Blur(lowbuf, coc,
|
|
MakeVector2(-sin60, cos60) * maxCoc);
|
|
lowbuf.Release();
|
|
}
|
|
{
|
|
GLProfiler p(dev, "Mix 1");
|
|
buf2 = AddMix(buf1, buf2);
|
|
}
|
|
//return buf2;
|
|
{
|
|
GLProfiler p(dev, "Blur 3");
|
|
buf1 = Blur(buf1, coc,
|
|
MakeVector2(-sin60, cos60) * maxCoc);
|
|
}
|
|
{
|
|
GLProfiler p(dev, "Blur 4");
|
|
buf2 = Blur(buf2, coc,
|
|
MakeVector2(sin60, cos60) * maxCoc);
|
|
}
|
|
|
|
dev->Viewport(0, 0, w, h);
|
|
{
|
|
GLProfiler p(dev, "Mix 2");
|
|
GLColorBuffer output = FinalMix(input,
|
|
buf1, buf2,
|
|
coc);
|
|
return output;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|