SHS/qad
4
1
Fork 0
Code Issues 5 Pull Requests Releases Wiki Activity
Files
b14cfe4a86560ba34e5dba77f8ff70f902734863
qad/qglview/renderer_deferred_shading.cpp

598 lines
23 KiB
C++
Raw Blame History

/*
QGLView
Copyright (C) 2020 Ivan Pelipenko peri4ko@yandex.ru
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_RGBA16F), 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)
<< ShaderPair("ssr", &shader_ssr)
<< ShaderPair("ssr_blur", &shader_ssr_blur)
<< ShaderPair("ssr_merge", &shader_ssr_merge)
<< ShaderPair("ssao_blur", &shader_ssao_blur)
<< ShaderPair("ssao_merge", &shader_ssao_merge)
<< ShaderPair("dof", &shader_dof);
for (int i = 0; i < shaders.size(); ++i)
*(shaders[i].second) = nullptr;
lights_per_pass = 8;
tnoise = 0;
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) {
QOpenGLShaderProgram * 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 = (mproj * mview).inverted();
QMatrix4x4 moffset = view.camera()->offsetMatrix();
QMatrix4x4 moffseti = moffset.inverted();
rp.prev_proj_matrix = prev_proj;
rp.prev_view_matrix = prev_view;
QMatrix4x4 vc_proji;
vc_proji.perspective(90., 1., view.camera()->depthStart(), view.camera()->depthEnd());
vc_proji = vc_proji.inverted();
corner_dirs[0] = (mproji * QVector4D(-1, -1, 0, 1));
corner_dirs[1] = (mproji * QVector4D( 1, -1, 0, 1));
corner_dirs[2] = (mproji * QVector4D(-1, 1, 0, 1));
corner_dirs[3] = (mproji * QVector4D( 1, 1, 0, 1));
//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) {
glActiveTexture(GL_TEXTURE0 + 6);
white_image_id = view.textureManager()->loadTexture(white_image, false);
glBindTexture(GL_TEXTURE_2D, white_image_id);
glActiveTexture(GL_TEXTURE0);
}
if (violent_image_id == 0) {
glActiveTexture(GL_TEXTURE0 + 7);
violent_image_id = view.textureManager()->loadTexture(violent_image, false);
glBindTexture(GL_TEXTURE_2D, violent_image_id);
glActiveTexture(GL_TEXTURE0);
}
glEnableDepth();
glClearFramebuffer(QColor(0, 0, 0, 0));
glDisable(GL_RESCALE_NORMAL);
shader_ds_0->bind();
rp.setUniform(shader_ds_0);
shader_ds_0->setUniformValue("z_far", view.depthEnd());
shader_ds_0->setUniformValue("z_near", 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.f / view.width(), 1.f / view.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, moffseti*mviewi);
l->shadow_map.release();
}
}
// glUseProgram(0);
//// fbo_g.bindColorTextures();
// glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(0));
// glActiveTexture(GL_TEXTURE0);
// glDrawQuad();
// return;
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", view.depthEnd());
shader_ds_1->setUniformValue("z_near", 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_view", mview);
shader_ds_1->setUniformValue("mat_viewi", mviewi);
shader_ds_1->setUniformValue("mat_viewproji", mviewproji);
shader_ds_1->setUniformValue("shadow_on", view.isFeatureEnabled(QGLView::qglShadowsEnabled) ? 1 : 0);
shader_ds_1->setUniformValue("dt", QVector2D(1.f / view.width(), 1.f / view.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);
int passes = (view.lightsCount() - 1) / lights_per_pass + 1;
if (passes < 1) passes = 1;
//qDebug() << "render in" << passes << "passes (" << lights_per_pass << ")";
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;
glActiveTexture(GL_TEXTURE0 + 6);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
fbo_out.setWriteBuffer(wi);
setupDSLights(l, mview * moffset);
glDrawQuad(shader_ds_1, corner_dirs);
//break;
}
//fbo_out.release();
wi = 1 - passes % 2;
ri = passes % 2;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
if (view.isFeatureEnabled(QGLView::qglSSAOEnabled)) {
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);
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(2));
glActiveTexture(GL_TEXTURE0 + 2);
glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(1));
glActiveTexture(GL_TEXTURE0);
//glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
//glActiveTextureChannel(1);
//glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(0));
int lri = ri, lwi = wi;//, lms = ri;
shader_ssao_blur->bind();
shader_ssao_blur->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_ssao_blur->setUniformValue("dt", QVector2D(1.f / fbo_out.width(), 1.f / fbo_out.height()));
shader_ssao_blur->setUniformValue("t0", 0);
shader_ssao_blur->setUniformValue("ts", 1);
shader_ssao_blur->setUniformValue("tg1", 2);
int passes = view.feature(QGLView::qglSSAORadius).toInt();
int crad = 1;
for (int p = 0; p < passes; ++p) {
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(lri));
fbo_out.setWriteBuffer(lwi);
shader_ssao_blur->setUniformValue("radius", GLfloat(crad));
glDrawQuad(shader_ssao_blur);
piSwap<int>(lwi, lri);
crad *= 2;
}
//qDebug() << wi << ri << lms;
/*wi = lri;
ri = 1 - lms;*/
glEnable(GL_TEXTURE_1D);
if (tnoise == 0) {
glGenTextures(1, &tnoise);
glBindTexture(GL_TEXTURE_1D, tnoise);
QByteArray ba;
for (int i = 0; i < 32*3; ++i)
ba.push_back(char(random() % 256));
//qDebug() << ba;
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB8, 32, 0, GL_RGB, GL_UNSIGNED_BYTE, ba.constData());
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(lri));
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(2));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glActiveTexture(GL_TEXTURE0 + 2);
glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(1));
glActiveTexture(GL_TEXTURE0 + 3);
glBindTexture(GL_TEXTURE_1D, tnoise);
shader_ssao_merge->bind();
shader_ssao_merge->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_ssao_merge->setUniformValue("z_far", view.depthEnd());
shader_ssao_merge->setUniformValue("z_near", view.depthStart());
shader_ssao_merge->setUniformValue("mat_proj", mproj);
shader_ssao_merge->setUniformValue("n0", 3);
shader_ssao_merge->setUniformValue("t0", 0);
shader_ssao_merge->setUniformValue("ts", 1);
shader_ssao_merge->setUniformValue("tg1", 2);
fbo_out.setWriteBuffer(lwi);
glDrawQuad(shader_ssao_merge, corner_dirs);
glDisable(GL_TEXTURE_1D);
wi = lri;
ri = lwi;
//piSwap<int>(wi, ri);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
//piSwap<int>(wi, ri);
}
if (view.isFeatureEnabled(QGLView::qglReflectionsEnabled)) {
fbo_out.setWriteBuffer(2);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);//_MIPMAP_LINEAR);
//glGenerateMipmap(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(0));
glActiveTexture(GL_TEXTURE0 + 2);
glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(1));
fbo_g.bindDepthTexture(7);
shader_ssr->bind();
shader_ssr->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_ssr->setUniformValue("z_far", view.depthEnd());
shader_ssr->setUniformValue("z_near", view.depthStart());
shader_ssr->setUniformValue("mat_proj", mproj);
shader_ssr->setUniformValue("t0", 1);
shader_ssr->setUniformValue("t1", 2);
shader_ssr->setUniformValue("ts", 0);
shader_ssr->setUniformValue("td", 7);
glDrawQuad(shader_ssr, corner_dirs);
glActiveTexture(GL_TEXTURE0);
int lri = 2, lwi = wi, lms = ri;
if (view.isFeatureEnabled(QGLView::qglReflectionsBlur)) {
shader_ssr_blur->bind();
shader_ssr_blur->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_ssr_blur->setUniformValue("dt", QVector2D(1.f / fbo_out.width(), 1.f / fbo_out.height()));
shader_ssr_blur->setUniformValue("t0", 0);
int passes = 5;
int crad = 1;
for (int p = 0; p < passes; ++p) {
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(lri));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);//_MIPMAP_LINEAR);
fbo_out.setWriteBuffer(lwi);
shader_ssr_blur->setUniformValue("radius", GLfloat(crad));
glDrawQuad(shader_ssr_blur);
piSwap<int>(lwi, lri);
crad *= 2;
}
}
//qDebug() << wi << ri << lms;
wi = lri;
ri = 1 - lms;
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(wi));
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, fbo_g.colorTexture(1));
glActiveTexture(GL_TEXTURE0 + 2);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(lms));
shader_ssr_merge->bind();
shader_ssr_merge->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_ssr_merge->setUniformValue("t0", 0);
shader_ssr_merge->setUniformValue("tg1", 1);
shader_ssr_merge->setUniformValue("ts", 2);
fbo_out.setWriteBuffer(ri);
glDrawQuad(shader_ssr_merge);
wi = ri;
ri = 1 - ri;
//piSwap<int>(wi, ri);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(wi));
piSwap<int>(wi, ri);
}
if (view.isFeatureEnabled(QGLView::qglDepthOfFieldEnabled)) {
if (view.isFeatureEnabled(QGLView::qglDepthOfFieldAutoFocusEnabled)) {
GLfloat cw;
//glReadBuffer();
fbo_g.bind();
glReadPixels(fbo_out.width() / 2, fbo_out.height() / 2, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &cw);
fbo_out.bind();
const float _pe = 2.4e-7f;
float cz = cw + cw - 1;
cz = ((_pe - 2.f) * view.depthStart()) / (cz + _pe - 1.f); // infinite depth
float z = view.feature(QGLView::qglDepthOfFieldFocus).toFloat(),
s = view.feature(QGLView::qglDepthOfFieldAutoFocusSpeed).toFloat();
z = z * (1.f - s) + cz * s;
view.setFeature(QGLView::qglDepthOfFieldFocus, z);
}
shader_dof->bind();
shader_dof->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_dof->setUniformValue("z_far", view.depthEnd());
shader_dof->setUniformValue("z_near", view.depthStart());
shader_dof->setUniformValue("focus", view.feature(QGLView::qglDepthOfFieldFocus).toFloat());
shader_dof->setUniformValue("diaphragm", view.feature(QGLView::qglDepthOfFieldDiaphragm).toFloat());
shader_dof->setUniformValue("t0", 0);
shader_dof->setUniformValue("td", 7);
fbo_g.bindDepthTexture(7);
glActiveTexture(GL_TEXTURE0);
int passes = 3;
float crad = 1.;
for (int p = 0; p < passes; ++p) {
shader_dof->setUniformValue("radius", crad);
fbo_out.setWriteBuffer(wi);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
shader_dof->setUniformValue("dt", QVector2D(1.f / fbo_out.width(), 0.f));
glDrawQuad(shader_dof);
piSwap<int>(wi, ri);
fbo_out.setWriteBuffer(wi);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
shader_dof->setUniformValue("dt", QVector2D(0.f, 1.f / fbo_out.height()));
glDrawQuad(shader_dof);
piSwap<int>(wi, ri);
crad *= 2.f;
}
glActiveTexture(GL_TEXTURE0);
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.299f * max[0]) + (0.587f * max[1]) + (0.114f * max[2]);
float nexp = mluma / 16.f, dexp = nexp - exposure_, mestep = exposure_ * view.feature(QGLView::qglEyeAccomodationMaxSpeed).toFloat();
dexp /= view.feature(QGLView::qglEyeAccomodationTime).toFloat();
if (dexp > 0.f && dexp > mestep/4) dexp = mestep/4;
if (dexp < 0.f && 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.f/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);
glActiveTexture(GL_TEXTURE0 + 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.f / fbo_out.width(), 1.f / fbo_out.height()));
shader_motion_blur->setUniformValue("t0", 0);
shader_motion_blur->setUniformValue("ts", 1);
shader_motion_blur->setUniformValue("factor", view.feature(QGLView::qglMotionBlurFactor).toFloat());
shader_motion_blur->setUniformValue("steps", view.feature(QGLView::qglMotionBlurSteps).toInt());
glDrawQuad(shader_motion_blur);
glActiveTexture(GL_TEXTURE0);
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);
//QTime tm;
//tm.restart();
fbo_out.setWriteBuffer(wi);
shader_bloom_0->bind();
shader_bloom_0->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_bloom_0->setUniformValue("factor", view.feature(QGLView::qglBloomFactor).toFloat());
shader_bloom_0->setUniformValue("threshold", view.feature(QGLView::qglBloomThreshold).toFloat());
shader_bloom_0->setUniformValue("t0", 0);
glDrawQuad(shader_bloom_0);
glActiveTexture(GL_TEXTURE0);
piSwap<int>(wi, ri);
shader_bloom_1->bind();
shader_bloom_1->setUniformValue("qgl_ModelViewProjectionMatrix", QMatrix4x4());
shader_bloom_1->setUniformValue("dt", QVector2D(1.f / fbo_out.width(), 1.f / 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;
}
//qDebug() << tm.elapsed();
fbo_out.setWriteBuffer(wi);
// glActiveTextureChannel(0);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(ri));
glActiveTexture(GL_TEXTURE0 + 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);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, fbo_out.colorTexture(wi));
piSwap<int>(wi, ri);
}
glUseProgram(0);
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.f / view.width(), 1.f / view.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) {
initializeOpenGLFunctions();
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));
//df->move(-width / 2, -height / 2);
}
void RendererDeferredShading::reloadShaders() {
for (int i = 0; i < shaders.size(); ++i) {
QOpenGLShaderProgram * p(*(shaders[i].second));
if (!p) p = new QOpenGLShaderProgram(view.context());
loadShaders(p, shaders[i].first, "://shaders");
*(shaders[i].second) = p;
}
}
void RendererDeferredShading::setupShadersTextures(GLObjectBase & object, GLRendererBase::RenderingParameters & rp) {
glActiveTexture(GL_TEXTURE0 + 6);
glBindTexture(GL_TEXTURE_2D, white_image_id);
glActiveTexture(GL_TEXTURE0 + 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];
glActiveTexture(GL_TEXTURE0 + shadow_start + i - light_start);
glBindTexture(GL_TEXTURE_2D, lv.back()->shadow_map.depthTexture());
if (view.isFeatureEnabled(QGLView::qglShadowsSoftEnabled)) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
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) {
}
Reference in New Issue View Git Blame Copy Permalink