384 lines
15 KiB
C++
384 lines
15 KiB
C++
/*
|
|
QGLView
|
|
Copyright (C) 2012 Ivan Pelipenko peri4ko@gmail.com
|
|
|
|
This program 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.
|
|
|
|
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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "renderer_deferred_shading.h"
|
|
#include <QBoxLayout>
|
|
|
|
|
|
RendererDeferredShading::RendererDeferredShading(QGLView * view_): GLRendererBase(view_),
|
|
fbo_g(5, true, GL_RGBA16F), fbo_out(3, false, GL_RGB16F), fbo_hsmall(1, false, GL_RGB16F) {
|
|
shaders << ShaderPair("FXAA", &shader_fxaa)
|
|
<< ShaderPair("dsl_pass_0", &shader_ds_0)
|
|
<< ShaderPair("dsl_pass_1", &shader_ds_1)
|
|
<< ShaderPair("hdr", &shader_hdr)
|
|
<< ShaderPair("downscale", &shader_small)
|
|
<< ShaderPair("bloom_pass_0", &shader_bloom_0)
|
|
<< ShaderPair("bloom_pass_1", &shader_bloom_1)
|
|
<< ShaderPair("fbo_add", &shader_fbo_add)
|
|
<< ShaderPair("motion_blur", &shader_motion_blur)
|
|
<< ShaderPair("shadow", &shader_shadow);
|
|
for (int i = 0; i < shaders.size(); ++i)
|
|
*(shaders[i].second) = 0;
|
|
lights_per_pass = 8;
|
|
exposure_ = 1.;
|
|
df = new QWidget();
|
|
df->setLayout(new QBoxLayout(QBoxLayout::TopToBottom));
|
|
label_exp = new QLabel();
|
|
label_exp_step = new QLabel();
|
|
df->layout()->addWidget(label_exp);
|
|
df->layout()->addWidget(label_exp_step);
|
|
QPalette pal(df->palette());
|
|
pal.setBrush(QPalette::Window, QColor(255, 255, 255, 192));
|
|
df->setPalette(pal);
|
|
if (view_)
|
|
view_->addObject(df);
|
|
}
|
|
|
|
|
|
RendererDeferredShading::~RendererDeferredShading() {
|
|
for (int i = 0; i < shaders.size(); ++i) {
|
|
QGLShaderProgram * p(*(shaders[i].second));
|
|
if (p) delete p;
|
|
}
|
|
delete df;
|
|
}
|
|
|
|
|
|
void RendererDeferredShading::renderScene() {
|
|
//qDebug() << lights_per_pass;
|
|
QMatrix4x4 mproj = rp.proj_matrix;
|
|
QMatrix4x4 mproji = rp.proj_matrix_i;
|
|
QMatrix4x4 mview = rp.view_matrix;
|
|
QMatrix4x4 mviewi = rp.view_matrix_i;
|
|
QMatrix4x4 mviewproji = (mview * mproj).inverted();
|
|
rp.prev_proj_matrix = prev_proj;
|
|
rp.prev_view_matrix = prev_view;
|
|
corner_dirs[0] = (QVector4D(-1, -1, 1, 1) * rp.viewproj_matrix).normalized();
|
|
corner_dirs[1] = (QVector4D( 1, -1, 1, 1) * rp.viewproj_matrix).normalized();
|
|
corner_dirs[2] = (QVector4D( 1, 1, 1, 1) * rp.viewproj_matrix).normalized();
|
|
corner_dirs[3] = (QVector4D(-1, 1, 1, 1) * rp.viewproj_matrix).normalized();
|
|
//qDebug() << corner_dirs[0] << corner_dirs[1] << corner_dirs[2] << corner_dirs[3];
|
|
fbo_g.bind();
|
|
int buffs[] = {0, 1, 2, 3, 4};
|
|
fbo_g.setWriteBuffers(buffs, 5);
|
|
if (white_image_id == 0) {
|
|
glActiveTextureChannel(6);
|
|
white_image_id = ((GLTextureManagerBase*)currentGLTextureManager)->loadTexture(white_image, false);
|
|
glBindTexture(GL_TEXTURE_2D, white_image_id);
|
|
glActiveTextureChannel(0);
|
|
}
|
|
if (violent_image_id == 0) {
|
|
glActiveTextureChannel(7);
|
|
violent_image_id = ((GLTextureManagerBase*)currentGLTextureManager)->loadTexture(violent_image, false);
|
|
glBindTexture(GL_TEXTURE_2D, violent_image_id);
|
|
glActiveTextureChannel(0);
|
|
}
|
|
glClearFramebuffer(QColor(0, 0, 0, 0));
|
|
glDisable(GL_RESCALE_NORMAL);
|
|
glEnableDepth();
|
|
shader_ds_0->bind();
|
|
rp.setUniform(shader_ds_0);
|
|
shader_ds_0->setUniformValue("z_far", GLfloat(view.depthEnd()));
|
|
shader_ds_0->setUniformValue("z_near", GLfloat(view.depthStart()));
|
|
shader_ds_0->setUniformValue("t0", 0);
|
|
shader_ds_0->setUniformValue("t1", 1);
|
|
shader_ds_0->setUniformValue("t2", 2);
|
|
shader_ds_0->setUniformValue("t3", 3);
|
|
shader_ds_0->setUniformValue("t4", 4);
|
|
shader_ds_0->setUniformValue("dt", QVector2D(1. / view.viewport()->width(), 1. / view.viewport()->height()));
|
|
//qDebug() << rp.view_matrix << prev_view;
|
|
//shader_ds_0->setUniformValue("qgl_ModelViewMatrix", rp.view_matrix);
|
|
renderObjects(GLObjectBase::Solid, 0, shader_ds_0, true, false, false);
|
|
//glReleaseShaders();
|
|
fbo_g.release();
|
|
|
|
if (view.isFeatureEnabled(QGLView::qglShadowsEnabled)) {
|
|
shader_shadow->bind();
|
|
int sms = view.feature(QGLView::qglShadowsMapSize).toInt();
|
|
glDisable(GL_TEXTURE_1D);
|
|
glDisable(GL_TEXTURE_2D);
|
|
glDisable(GL_TEXTURE_CUBE_MAP);
|
|
glDisable(GL_MULTISAMPLE);
|
|
glDisable(GL_LIGHTING);
|
|
glDisable(GL_BLEND);
|
|
glDisable(GL_ALPHA_TEST);
|
|
glDisable(GL_RESCALE_NORMAL);
|
|
glDisableClientState(GL_NORMAL_ARRAY);
|
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
|
//qDebug() << "render shadows";
|
|
for (int i = 0; i < view.lightsCount(); ++i) {
|
|
Light * l = view.light(i);
|
|
if (l->light_type == Light::Omni) continue;
|
|
l->shadow_map.resize(sms, sms);
|
|
l->shadow_map.bind();
|
|
//l->shadow_map.setWriteBuffer(0);
|
|
//glClearFramebuffer();
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
renderShadow(l, shader_shadow, mviewi);
|
|
l->shadow_map.release();
|
|
}
|
|
}
|
|
|
|
glResetAllTransforms();
|
|
glSetLightEnabled(false);
|
|
glEnable(GL_TEXTURE_2D);
|
|
glDisable(GL_BLEND);
|
|
//glBlendFunc(GL_ONE, GL_ONE);
|
|
glDisableDepth();
|
|
rp.prepare();
|
|
//qDebug() << rp.view_matrix;
|
|
shader_ds_1->bind();
|
|
shader_ds_1->setUniformValue("z_far", GLfloat(view.depthEnd()));
|
|
shader_ds_1->setUniformValue("z_near", GLfloat(view.depthStart()));
|
|
shader_ds_1->setUniformValue("t0", 0);
|
|
shader_ds_1->setUniformValue("t1", 1);
|
|
shader_ds_1->setUniformValue("t2", 2);
|
|
shader_ds_1->setUniformValue("t3", 3);
|
|
shader_ds_1->setUniformValue("t4", 4);
|
|
shader_ds_1->setUniformValue("td", 5);
|
|
shader_ds_1->setUniformValue("back_color", view.backColor());
|
|
shader_ds_1->setUniformValue("mat_proji", mproji);
|
|
shader_ds_1->setUniformValue("mat_viewi", mviewi);
|
|
shader_ds_1->setUniformValue("mat_viewproji", mviewproji);
|
|
shader_ds_1->setUniformValue("dt", QVector2D(1. / view.viewport()->width(), 1. / view.viewport()->height()));
|
|
rp.setUniform(shader_ds_1);
|
|
fbo_g.bindColorTextures();
|
|
fbo_g.bindDepthTexture(5);
|
|
fbo_out.bind();
|
|
fbo_out.setWriteBuffer(0);
|
|
glClearFramebuffer(Qt::black, false);
|
|
//QVector<QVector4D> lpos;
|
|
//qDebug() << view_matrix;
|
|
shader_ds_1->setUniformValue("t_pp", 6);
|
|
//qDebug() << "render in" << passes << "passes (" << lights_per_pass << ")";
|
|
int passes = (view.lightsCount() - 1) / lights_per_pass + 1;
|
|
if (passes < 1) passes = 1;
|
|
int wi, ri;
|
|
for (int l = 0; l < passes; ++l) {
|
|
wi = 1 - l % 2;
|
|
ri = l % 2;
|
|
//qDebug() << " pass" << l << "read from" << ri << "write to" << wi;
|
|
glActiveTextureChannel(6);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
|
|
fbo_out.setWriteBuffer(wi);
|
|
setupDSLights(l, mview);
|
|
glDrawQuad(shader_ds_1);
|
|
//break;
|
|
}
|
|
//fbo_out.release();
|
|
wi = 1 - passes % 2;
|
|
ri = passes % 2;
|
|
glActiveTextureChannel(0);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
|
|
|
|
if (view.isFeatureEnabled(QGLView::qglEyeAccomodationEnabled)) {
|
|
fbo_hsmall.bind();
|
|
fbo_hsmall.setWriteBuffer(0);
|
|
shader_small->bind();
|
|
shader_small->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
|
|
shader_small->setUniformValue("t0", 0);
|
|
glDrawQuad(shader_small);
|
|
hcontent.resize(fbo_hsmall.width() * fbo_hsmall.height());
|
|
glReadPixels(0, 0, fbo_hsmall.width(), fbo_hsmall.height(), GL_RGB, GL_FLOAT, hcontent.data());
|
|
GLfloat max[3] = {0.,0.,0.};//min[3] = {10000.,10000.,10000.}, ;
|
|
for (int i = 0; i < hcontent.size(); ++i) {
|
|
//if (min[0] > hcontent[i].x) min[0] = hcontent[i].x;
|
|
if (max[0] < hcontent[i].x) max[0] = hcontent[i].x;
|
|
//if (min[1] > hcontent[i].y) min[1] = hcontent[i].y;
|
|
if (max[1] < hcontent[i].y) max[1] = hcontent[i].y;
|
|
//if (min[2] > hcontent[i].z) min[2] = hcontent[i].z;
|
|
if (max[2] < hcontent[i].z) max[2] = hcontent[i].z;
|
|
}
|
|
GLfloat mluma = (0.299 * max[0]) + (0.587 * max[1]) + (0.114 * max[2]);
|
|
double nexp = mluma / 16., dexp = nexp - exposure_, mestep = exposure_ * view.feature(QGLView::qglEyeAccomodationMaxSpeed).toDouble();
|
|
dexp /= view.feature(QGLView::qglEyeAccomodationTime).toDouble();
|
|
if (dexp > 0. && dexp > mestep/4) dexp = mestep/4;
|
|
if (dexp < 0. && dexp < -mestep) dexp = -mestep;
|
|
exposure_ += dexp;
|
|
label_exp->setText(QString("exposure: %1").arg(exposure_));
|
|
label_exp_step->setText(QString("d_exposure: %1").arg(dexp));
|
|
//qDebug() << min[0] << max[0] << min[1] << max[1] << min[2] << max[2];
|
|
fbo_hsmall.release();
|
|
|
|
//glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
|
|
fbo_out.bind();
|
|
fbo_out.setWriteBuffer(wi);
|
|
shader_hdr->bind();
|
|
shader_hdr->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
|
|
shader_hdr->setUniformValue("t0", 0);
|
|
shader_hdr->setUniformValue("exposure", GLfloat(1./exposure_));
|
|
glDrawQuad(shader_hdr);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(wi));
|
|
piSwap<int>(wi, ri);
|
|
}
|
|
|
|
if (view.isFeatureEnabled(QGLView::qglMotionBlurEnabled)) {
|
|
fbo_out.setWriteBuffer(wi);
|
|
glActiveTextureChannel(1);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(4));
|
|
shader_motion_blur->bind();
|
|
shader_motion_blur->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
|
|
shader_motion_blur->setUniformValue("dt", QVector2D(1. / fbo_out.width(), 1. / fbo_out.height()));
|
|
shader_motion_blur->setUniformValue("t0", 0);
|
|
shader_motion_blur->setUniformValue("ts", 1);
|
|
shader_motion_blur->setUniformValue("factor", GLfloat(view.feature(QGLView::qglMotionBlurFactor).toDouble()));
|
|
shader_motion_blur->setUniformValue("steps", view.feature(QGLView::qglMotionBlurSteps).toInt());
|
|
glDrawQuad(shader_motion_blur);
|
|
glActiveTextureChannel(0);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(wi));
|
|
piSwap<int>(wi, ri);
|
|
}
|
|
|
|
if (view.isFeatureEnabled(QGLView::qglBloomEnabled)) {
|
|
fbo_out.setWriteBuffer(2);
|
|
fbo_out.setReadBuffer(ri);
|
|
glBlitFramebuffer(0, 0, fbo_out.width(), fbo_out.height(), 0, 0, fbo_out.width(), fbo_out.height(), GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
|
|
|
fbo_out.setWriteBuffer(wi);
|
|
shader_bloom_0->bind();
|
|
shader_bloom_0->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
|
|
shader_bloom_0->setUniformValue("factor", GLfloat(view.feature(QGLView::qglBloomFactor).toDouble()));
|
|
shader_bloom_0->setUniformValue("threshold", GLfloat(view.feature(QGLView::qglBloomThreshold).toDouble()));
|
|
shader_bloom_0->setUniformValue("t0", 0);
|
|
glDrawQuad(shader_bloom_0);
|
|
glActiveTextureChannel(0);
|
|
piSwap<int>(wi, ri);
|
|
|
|
shader_bloom_1->bind();
|
|
shader_bloom_1->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
|
|
shader_bloom_1->setUniformValue("dt", QVector2D(1. / fbo_out.width(), 1. / fbo_out.height()));
|
|
shader_bloom_1->setUniformValue("t0", 0);
|
|
int radius = view.feature(QGLView::qglBloomRadius).toInt();
|
|
int passes = qMax<int>(int(ceil(log2(radius))), 1);
|
|
int crad = 1;
|
|
for (int p = 0; p < passes; ++p) {
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
|
|
fbo_out.setWriteBuffer(wi);
|
|
if (p == passes - 1)
|
|
crad = piMax(1, radius - crad);
|
|
shader_bloom_1->setUniformValue("radius", crad);
|
|
glDrawQuad(shader_bloom_1);
|
|
piSwap<int>(wi, ri);
|
|
crad *= 2;
|
|
}
|
|
|
|
fbo_out.setWriteBuffer(wi);
|
|
glActiveTextureChannel(0);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
|
|
glActiveTextureChannel(1);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(2));
|
|
shader_fbo_add->bind();
|
|
shader_fbo_add->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
|
|
shader_fbo_add->setUniformValue("t0", 0);
|
|
shader_fbo_add->setUniformValue("t1", 1);
|
|
glDrawQuad(shader_fbo_add);
|
|
glActiveTextureChannel(0);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(wi));
|
|
piSwap<int>(wi, ri);
|
|
}
|
|
|
|
glReleaseShaders();
|
|
fbo_out.release();
|
|
|
|
if (view.isFeatureEnabled(QGLView::qglFXAA)) {
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
shader_fxaa->bind();
|
|
shader_fxaa->setUniformValue("dt", QVector2D(1. / view.viewport()->width(), 1. / view.viewport()->height()));
|
|
} else {
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
}
|
|
glDrawQuad();
|
|
if (view.isFeatureEnabled(QGLView::qglFXAA))
|
|
shader_fxaa->release();
|
|
prev_proj = mproj;
|
|
prev_view = mview;
|
|
}
|
|
|
|
|
|
void RendererDeferredShading::init(int width, int height) {
|
|
resize(width, height);
|
|
}
|
|
|
|
|
|
void RendererDeferredShading::resize(int width, int height) {
|
|
fbo_g.resize(width, height);
|
|
fbo_out.resize(width, height);
|
|
fbo_hsmall.resize(width / 16, height / 16);
|
|
view.setSceneRect(QRect(0, 0, width, height)); /// WARNING
|
|
//df->move(-width / 2, -height / 2);
|
|
}
|
|
|
|
|
|
void RendererDeferredShading::reloadShaders() {
|
|
for (int i = 0; i < shaders.size(); ++i) {
|
|
QGLShaderProgram * p(*(shaders[i].second));
|
|
if (!p) p = new QGLShaderProgram(view.context());
|
|
loadShaders(p, shaders[i].first, "shaders");
|
|
*(shaders[i].second) = p;
|
|
}
|
|
}
|
|
|
|
|
|
void RendererDeferredShading::setupShadersTextures(GLObjectBase & object, GLRendererBase::RenderingParameters & rp) {
|
|
shader_ds_0->setUniformValue("has_diffuse", object.material().map_diffuse.bitmap_id != 0);
|
|
shader_ds_0->setUniformValue("has_bump", object.material().map_normal.bitmap_id != 0);
|
|
shader_ds_0->setUniformValue("has_height", object.material().map_relief.bitmap_id != 0);
|
|
shader_ds_0->setUniformValue("bump_scale", object.material().map_normal.color_amount);
|
|
shader_ds_0->setUniformValue("height_scale", object.material().map_relief.color_amount);
|
|
glActiveTextureChannel(6);
|
|
glBindTexture(GL_TEXTURE_2D, white_image_id);
|
|
glActiveTextureChannel(7);
|
|
glBindTexture(GL_TEXTURE_2D, violent_image_id);
|
|
}
|
|
|
|
|
|
void RendererDeferredShading::setupDSLights(int pass, const QMatrix4x4 & view_matrix) {
|
|
int light_start, light_end, lmax, shadow_start = 7;
|
|
light_start = pass * lights_per_pass;
|
|
light_end = qMin<int>((pass + 1) * lights_per_pass, view.lights().size());
|
|
lmax = light_start + lights_per_pass;
|
|
amb_light.intensity = (pass == 0 ? 1. : 0.);
|
|
amb_light.setColor(pass == 0 ? view.ambientColor() : Qt::black);
|
|
amb_light.setName("ambient");
|
|
setUniformLight(shader_ds_1, &amb_light, "qgl_AmbientLight");
|
|
amb_light.intensity = 0.;
|
|
QVector<Light*> lv;
|
|
for (int i = light_start; i < light_end; ++i) {
|
|
lv << view.lights()[i];
|
|
glActiveTextureChannel(shadow_start + i - light_start);
|
|
glBindTexture(GL_TEXTURE_2D, lv.back()->shadow_map.depthTexture());
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
|
}
|
|
amb_light.setName("null");
|
|
for (int i = light_end; i < lmax; ++i)
|
|
lv << &amb_light;
|
|
//QStringList lnl; foreach (Light * l, lv) lnl << l->name();
|
|
//qDebug() << " lights" << light_start << "->" << light_end << ", inactive" << (lmax - light_end) << lnl;
|
|
setUniformLights(shader_ds_1, lv, view_matrix, shadow_start);
|
|
}
|
|
|
|
|
|
void RendererDeferredShading::setupAmbientLight(const QColor & a, bool first_pass) {
|
|
|
|
}
|