mirror of
https://github.com/JulianGro/overte.git
synced 2025-04-29 17:02:57 +02:00
668 lines
26 KiB
C++
668 lines
26 KiB
C++
//
|
|
// DeferredLightingEffect.cpp
|
|
// interface/src/renderer
|
|
//
|
|
// Created by Andrzej Kapolka on 9/11/14.
|
|
// Copyright 2014 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#include "DeferredLightingEffect.h"
|
|
#include <QtCore/QFileSelector>
|
|
|
|
#include <GLMHelpers.h>
|
|
#include <PathUtils.h>
|
|
#include <ViewFrustum.h>
|
|
#include <shared/FileUtils.h>
|
|
#include <gpu/Batch.h>
|
|
#include <gpu/Context.h>
|
|
#include <shaders/Shaders.h>
|
|
|
|
#include <graphics/ShaderConstants.h>
|
|
|
|
#include "render-utils/ShaderConstants.h"
|
|
#include "StencilMaskPass.h"
|
|
#include "AbstractViewStateInterface.h"
|
|
#include "GeometryCache.h"
|
|
#include "TextureCache.h"
|
|
#include "FramebufferCache.h"
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
|
|
namespace ru {
|
|
using render_utils::slot::texture::Texture;
|
|
using render_utils::slot::buffer::Buffer;
|
|
}
|
|
|
|
namespace gr {
|
|
using graphics::slot::texture::Texture;
|
|
using graphics::slot::buffer::Buffer;
|
|
}
|
|
|
|
using namespace render;
|
|
|
|
static void loadLightProgram(int programId, bool lightVolume, gpu::PipelinePointer& program);
|
|
|
|
void DeferredLightingEffect::init() {
|
|
loadLightProgram(shader::render_utils::program::directional_skybox_light_ambient, false, _directionalAmbientSphereLight);
|
|
loadLightProgram(shader::render_utils::program::directional_skybox_light, false, _directionalSkyboxLight);
|
|
|
|
loadLightProgram(shader::render_utils::program::directional_skybox_light_ambient_shadow, false, _directionalAmbientSphereLightShadow);
|
|
loadLightProgram(shader::render_utils::program::directional_skybox_light_shadow, false, _directionalSkyboxLightShadow);
|
|
|
|
loadLightProgram(shader::render_utils::program::local_lights_shading, true, _localLight);
|
|
loadLightProgram(shader::render_utils::program::local_lights_drawOutline, true, _localLightOutline);
|
|
}
|
|
|
|
// FIXME: figure out how to move lightFrame into a varying in GeometryCache and RenderPipelines
|
|
void DeferredLightingEffect::setupKeyLightBatch(const RenderArgs* args, gpu::Batch& batch) {
|
|
setupKeyLightBatch(args, batch, args->_scene->getStage<LightStage>()->_currentFrame);
|
|
}
|
|
|
|
void DeferredLightingEffect::setupKeyLightBatch(const RenderArgs* args, gpu::Batch& batch, const LightStage::Frame& lightFrame) {
|
|
PerformanceTimer perfTimer("DLE->setupBatch()");
|
|
graphics::LightPointer keySunLight;
|
|
auto lightStage = args->_scene->getStage<LightStage>();
|
|
if (lightStage) {
|
|
keySunLight = lightStage->getCurrentKeyLight(lightFrame);
|
|
}
|
|
|
|
graphics::LightPointer keyAmbiLight;
|
|
if (lightStage) {
|
|
keyAmbiLight = lightStage->getCurrentAmbientLight(lightFrame);
|
|
}
|
|
|
|
if (keySunLight) {
|
|
batch.setUniformBuffer(gr::Buffer::KeyLight, keySunLight->getLightSchemaBuffer());
|
|
}
|
|
|
|
if (keyAmbiLight) {
|
|
batch.setUniformBuffer(gr::Buffer::AmbientLight, keyAmbiLight->getAmbientSchemaBuffer());
|
|
|
|
if (keyAmbiLight->getAmbientMap() ) {
|
|
batch.setResourceTexture(ru::Texture::Skybox, keyAmbiLight->getAmbientMap());
|
|
}
|
|
}
|
|
}
|
|
|
|
void DeferredLightingEffect::unsetKeyLightBatch(gpu::Batch& batch) {
|
|
batch.setUniformBuffer(gr::Buffer::KeyLight, nullptr);
|
|
batch.setUniformBuffer(gr::Buffer::AmbientLight, nullptr);
|
|
batch.setResourceTexture(ru::Texture::Skybox, nullptr);
|
|
}
|
|
|
|
void DeferredLightingEffect::setupLocalLightsBatch(gpu::Batch& batch, const LightClustersPointer& lightClusters) {
|
|
// Bind the global list of lights and the visible lights this frame
|
|
batch.setUniformBuffer(gr::Buffer::Light, lightClusters->_lightStage->getLightArrayBuffer());
|
|
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterFrustumGrid, lightClusters->_frustumGridBuffer);
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterGrid, lightClusters->_clusterGridBuffer);
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterContent, lightClusters->_clusterContentBuffer);
|
|
}
|
|
|
|
void DeferredLightingEffect::unsetLocalLightsBatch(gpu::Batch& batch) {
|
|
batch.setUniformBuffer(gr::Buffer::Light, nullptr);
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterGrid, nullptr);
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterContent, nullptr);
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterFrustumGrid, nullptr);
|
|
}
|
|
|
|
static void loadLightProgram(int programId, bool lightVolume, gpu::PipelinePointer& pipeline) {
|
|
|
|
gpu::ShaderPointer program = gpu::Shader::createProgram(programId);
|
|
|
|
auto state = std::make_shared<gpu::State>();
|
|
state->setColorWriteMask(true, true, true, false);
|
|
|
|
if (lightVolume) {
|
|
PrepareStencil::testShape(*state);
|
|
|
|
state->setCullMode(gpu::State::CULL_BACK);
|
|
//state->setCullMode(gpu::State::CULL_FRONT);
|
|
//state->setDepthTest(true, false, gpu::GREATER_EQUAL);
|
|
//state->setDepthClampEnable(true);
|
|
// TODO: We should use DepthClamp and avoid changing geometry for inside /outside cases
|
|
// additive blending
|
|
state->setBlendFunction(true, gpu::State::ONE, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
|
|
|
|
} else {
|
|
// Stencil test all the light passes for objects pixels only, not the background
|
|
PrepareStencil::testShape(*state);
|
|
|
|
state->setCullMode(gpu::State::CULL_BACK);
|
|
// additive blending
|
|
state->setBlendFunction(true, gpu::State::ONE, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
|
|
}
|
|
pipeline = gpu::Pipeline::create(program, state);
|
|
|
|
}
|
|
|
|
#include <shared/Shapes.h>
|
|
|
|
graphics::MeshPointer DeferredLightingEffect::getPointLightMesh() {
|
|
if (!_pointLightMesh) {
|
|
_pointLightMesh = std::make_shared<graphics::Mesh>();
|
|
|
|
// let's use a icosahedron
|
|
auto solid = geometry::icosahedron();
|
|
solid.fitDimension(1.05f); // scaled to 1.05 meters, it will be scaled by the shader accordingly to the light size
|
|
|
|
int verticesSize = (int) (solid.vertices.size() * 3 * sizeof(float));
|
|
float* vertexData = (float*) solid.vertices.data();
|
|
|
|
_pointLightMesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(verticesSize, (gpu::Byte*) vertexData), gpu::Element::VEC3F_XYZ));
|
|
|
|
int nbIndices = (int) solid.faces.size() * 3;
|
|
|
|
gpu::uint16* indexData = new gpu::uint16[nbIndices];
|
|
gpu::uint16* index = indexData;
|
|
for (auto face : solid.faces) {
|
|
*(index++) = face[0];
|
|
*(index++) = face[1];
|
|
*(index++) = face[2];
|
|
}
|
|
|
|
_pointLightMesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(sizeof(unsigned short) * nbIndices, (gpu::Byte*) indexData), gpu::Element::INDEX_UINT16));
|
|
delete[] indexData;
|
|
|
|
|
|
std::vector<graphics::Mesh::Part> parts;
|
|
parts.push_back(graphics::Mesh::Part(0, nbIndices, 0, graphics::Mesh::TRIANGLES));
|
|
parts.push_back(graphics::Mesh::Part(0, nbIndices, 0, graphics::Mesh::LINE_STRIP)); // outline version
|
|
|
|
|
|
_pointLightMesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
|
|
}
|
|
return _pointLightMesh;
|
|
}
|
|
|
|
graphics::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
|
|
if (!_spotLightMesh) {
|
|
_spotLightMesh = std::make_shared<graphics::Mesh>();
|
|
|
|
int slices = 16;
|
|
int rings = 3;
|
|
int vertices = 2 + rings * slices;
|
|
int originVertex = vertices - 2;
|
|
int capVertex = vertices - 1;
|
|
int verticesSize = vertices * 3 * sizeof(float);
|
|
int indices = 3 * slices * (1 + 1 + 2 * (rings -1));
|
|
int ringFloatOffset = slices * 3;
|
|
|
|
|
|
float* vertexData = new float[verticesSize];
|
|
float* vertexRing0 = vertexData;
|
|
float* vertexRing1 = vertexRing0 + ringFloatOffset;
|
|
float* vertexRing2 = vertexRing1 + ringFloatOffset;
|
|
|
|
for (int i = 0; i < slices; i++) {
|
|
float theta = TWO_PI * i / slices;
|
|
auto cosin = glm::vec2(cosf(theta), sinf(theta));
|
|
|
|
*(vertexRing0++) = cosin.x;
|
|
*(vertexRing0++) = cosin.y;
|
|
*(vertexRing0++) = 0.0f;
|
|
|
|
*(vertexRing1++) = cosin.x;
|
|
*(vertexRing1++) = cosin.y;
|
|
*(vertexRing1++) = 0.33f;
|
|
|
|
*(vertexRing2++) = cosin.x;
|
|
*(vertexRing2++) = cosin.y;
|
|
*(vertexRing2++) = 0.66f;
|
|
}
|
|
|
|
*(vertexRing2++) = 0.0f;
|
|
*(vertexRing2++) = 0.0f;
|
|
*(vertexRing2++) = -1.0f;
|
|
|
|
*(vertexRing2++) = 0.0f;
|
|
*(vertexRing2++) = 0.0f;
|
|
*(vertexRing2++) = 1.0f;
|
|
|
|
_spotLightMesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(verticesSize, (gpu::Byte*) vertexData), gpu::Element::VEC3F_XYZ));
|
|
delete[] vertexData;
|
|
|
|
gpu::uint16* indexData = new gpu::uint16[indices];
|
|
gpu::uint16* index = indexData;
|
|
for (int i = 0; i < slices; i++) {
|
|
*(index++) = originVertex;
|
|
|
|
int s0 = i;
|
|
int s1 = ((i + 1) % slices);
|
|
*(index++) = s0;
|
|
*(index++) = s1;
|
|
|
|
int s2 = s0 + slices;
|
|
int s3 = s1 + slices;
|
|
*(index++) = s1;
|
|
*(index++) = s0;
|
|
*(index++) = s2;
|
|
|
|
*(index++) = s1;
|
|
*(index++) = s2;
|
|
*(index++) = s3;
|
|
|
|
int s4 = s2 + slices;
|
|
int s5 = s3 + slices;
|
|
*(index++) = s3;
|
|
*(index++) = s2;
|
|
*(index++) = s4;
|
|
|
|
*(index++) = s3;
|
|
*(index++) = s4;
|
|
*(index++) = s5;
|
|
|
|
|
|
*(index++) = s5;
|
|
*(index++) = s4;
|
|
*(index++) = capVertex;
|
|
}
|
|
|
|
_spotLightMesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(sizeof(unsigned short) * indices, (gpu::Byte*) indexData), gpu::Element::INDEX_UINT16));
|
|
delete[] indexData;
|
|
|
|
|
|
std::vector<graphics::Mesh::Part> parts;
|
|
parts.push_back(graphics::Mesh::Part(0, indices, 0, graphics::Mesh::TRIANGLES));
|
|
parts.push_back(graphics::Mesh::Part(0, indices, 0, graphics::Mesh::LINE_STRIP)); // outline version
|
|
|
|
|
|
_spotLightMesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
|
|
}
|
|
return _spotLightMesh;
|
|
}
|
|
|
|
void PrepareDeferred::run(const RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs) {
|
|
auto args = renderContext->args;
|
|
|
|
auto primaryFramebuffer = inputs.get0();
|
|
auto lightingModel = inputs.get1();
|
|
|
|
if (!_deferredFramebuffer) {
|
|
_deferredFramebuffer = std::make_shared<DeferredFramebuffer>();
|
|
}
|
|
_deferredFramebuffer->updatePrimaryDepth(primaryFramebuffer->getDepthStencilBuffer());
|
|
|
|
outputs.edit0() = _deferredFramebuffer;
|
|
outputs.edit1() = _deferredFramebuffer->getLightingFramebuffer();
|
|
|
|
gpu::doInBatch("PrepareDeferred::run", args->_context, [&](gpu::Batch& batch) {
|
|
batch.enableStereo(false);
|
|
batch.setViewportTransform(args->_viewport);
|
|
batch.setStateScissorRect(args->_viewport);
|
|
|
|
// Clear deferred
|
|
auto deferredFbo = _deferredFramebuffer->getDeferredFramebuffer();
|
|
batch.setFramebuffer(deferredFbo);
|
|
|
|
// Clear Color, Depth and Stencil for deferred buffer
|
|
batch.clearFramebuffer(
|
|
gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | gpu::Framebuffer::BUFFER_COLOR2 | gpu::Framebuffer::BUFFER_COLOR3 |
|
|
gpu::Framebuffer::BUFFER_DEPTH |
|
|
gpu::Framebuffer::BUFFER_STENCIL,
|
|
vec4(vec3(0), 0), 1.0, 0, true);
|
|
|
|
// For the rest of the rendering, bind the lighting model
|
|
batch.setUniformBuffer(ru::Buffer::LightModel, lightingModel->getParametersBuffer());
|
|
batch.setResourceTexture(ru::Texture::AmbientFresnel, lightingModel->getAmbientFresnelLUT());
|
|
});
|
|
}
|
|
|
|
|
|
void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
|
|
const DeferredFrameTransformPointer& frameTransform,
|
|
const DeferredFramebufferPointer& deferredFramebuffer,
|
|
const LightingModelPointer& lightingModel,
|
|
const LightStage::FramePointer& lightFrame,
|
|
const LightStage::ShadowFramePointer& shadowFrame,
|
|
const HazeStage::FramePointer& hazeFrame,
|
|
const SurfaceGeometryFramebufferPointer& surfaceGeometryFramebuffer,
|
|
const AmbientOcclusionFramebufferPointer& ambientOcclusionFramebuffer,
|
|
const SubsurfaceScatteringResourcePointer& subsurfaceScatteringResource) {
|
|
|
|
auto args = renderContext->args;
|
|
auto& batch = (*args->_batch);
|
|
{
|
|
// Framebuffer copy operations cannot function as multipass stereo operations.
|
|
batch.enableStereo(false);
|
|
|
|
auto textureCache = DependencyManager::get<TextureCache>();
|
|
auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
|
|
|
|
// binding the first framebuffer
|
|
auto lightingFBO = deferredFramebuffer->getLightingFramebuffer();
|
|
batch.setFramebuffer(lightingFBO);
|
|
|
|
batch.setViewportTransform(args->_viewport);
|
|
batch.setStateScissorRect(args->_viewport);
|
|
|
|
|
|
// Bind the G-Buffer surfaces
|
|
batch.setResourceTexture(ru::Texture::DeferredColor, deferredFramebuffer->getDeferredColorTexture());
|
|
batch.setResourceTexture(ru::Texture::DeferredNormal, deferredFramebuffer->getDeferredNormalTexture());
|
|
batch.setResourceTexture(ru::Texture::DeferredSpecular, deferredFramebuffer->getDeferredSpecularTexture());
|
|
batch.setResourceTexture(ru::Texture::DeferredDepth, deferredFramebuffer->getPrimaryDepthTexture());
|
|
|
|
// FIXME: Different render modes should have different tasks
|
|
if (lightingModel->isAmbientOcclusionEnabled() && ambientOcclusionFramebuffer) {
|
|
batch.setResourceTexture(ru::Texture::DeferredObscurance, ambientOcclusionFramebuffer->getOcclusionTexture());
|
|
} else {
|
|
// need to assign the white texture if ao is off
|
|
batch.setResourceTexture(ru::Texture::DeferredObscurance, textureCache->getWhiteTexture());
|
|
}
|
|
|
|
// The Deferred Frame Transform buffer
|
|
batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, frameTransform->getFrameTransformBuffer());
|
|
|
|
// THe lighting model
|
|
batch.setUniformBuffer(ru::Buffer::LightModel, lightingModel->getParametersBuffer());
|
|
batch.setResourceTexture(ru::Texture::AmbientFresnel, lightingModel->getAmbientFresnelLUT());
|
|
|
|
// Subsurface scattering specific
|
|
if (surfaceGeometryFramebuffer) {
|
|
batch.setResourceTexture(ru::Texture::DeferredLinearZEye, surfaceGeometryFramebuffer->getLinearDepthTexture());
|
|
batch.setResourceTexture(ru::Texture::DeferredCurvature, surfaceGeometryFramebuffer->getCurvatureTexture());
|
|
batch.setResourceTexture(ru::Texture::DeferredDiffusedCurvature, surfaceGeometryFramebuffer->getLowCurvatureTexture());
|
|
}
|
|
if (subsurfaceScatteringResource) {
|
|
batch.setUniformBuffer(ru::Buffer::SsscParams, subsurfaceScatteringResource->getParametersBuffer());
|
|
batch.setResourceTexture(ru::Texture::SsscLut, subsurfaceScatteringResource->getScatteringTable());
|
|
batch.setResourceTexture(ru::Texture::SsscSpecularBeckmann, subsurfaceScatteringResource->getScatteringSpecular());
|
|
}
|
|
|
|
// Global directional light, maybe shadow and ambient pass
|
|
auto lightStage = renderContext->_scene->getStage<LightStage>();
|
|
assert(lightStage);
|
|
assert(lightStage->getNumLights() > 0);
|
|
auto keyLight = lightStage->getCurrentKeyLight(*lightFrame);
|
|
|
|
// Check if keylight casts shadows
|
|
bool keyLightCastShadows{ false };
|
|
LightStage::ShadowPointer globalShadow;
|
|
if (lightingModel->isShadowEnabled() && shadowFrame && !shadowFrame->_objects.empty()) {
|
|
globalShadow = shadowFrame->_objects.front();
|
|
if (globalShadow) {
|
|
keyLightCastShadows = true;
|
|
}
|
|
}
|
|
|
|
// Global Ambient light
|
|
graphics::LightPointer ambientLight;
|
|
if (lightStage && lightFrame->_ambientLights.size()) {
|
|
ambientLight = lightStage->getLight(lightFrame->_ambientLights.front());
|
|
}
|
|
bool hasAmbientMap = (ambientLight != nullptr);
|
|
|
|
// Setup the global directional pass pipeline
|
|
auto program = deferredLightingEffect->_directionalSkyboxLight;
|
|
{
|
|
if (keyLightCastShadows) {
|
|
|
|
// If the keylight has an ambient Map then use the Skybox version of the pass
|
|
// otherwise use the ambient sphere version
|
|
if (hasAmbientMap) {
|
|
program = deferredLightingEffect->_directionalSkyboxLightShadow;
|
|
} else {
|
|
program = deferredLightingEffect->_directionalAmbientSphereLightShadow;
|
|
}
|
|
} else {
|
|
// If the keylight has an ambient Map then use the Skybox version of the pass
|
|
// otherwise use the ambient sphere version
|
|
if (hasAmbientMap) {
|
|
program = deferredLightingEffect->_directionalSkyboxLight;
|
|
} else {
|
|
program = deferredLightingEffect->_directionalAmbientSphereLight;
|
|
}
|
|
}
|
|
|
|
if (keyLightCastShadows && globalShadow) {
|
|
batch.setResourceTexture(ru::Texture::Shadow, globalShadow->map);
|
|
batch.setUniformBuffer(ru::Buffer::ShadowParams, globalShadow->getBuffer());
|
|
}
|
|
|
|
batch.setPipeline(program);
|
|
}
|
|
|
|
// Setup the global lighting
|
|
deferredLightingEffect->setupKeyLightBatch(args, batch, *lightFrame);
|
|
|
|
// Haze
|
|
const auto& hazeStage = args->_scene->getStage<HazeStage>();
|
|
if (hazeStage && hazeFrame->_hazes.size() > 0) {
|
|
const auto& hazePointer = hazeStage->getHaze(hazeFrame->_hazes.front());
|
|
if (hazePointer) {
|
|
batch.setUniformBuffer(graphics::slot::buffer::Buffer::HazeParams, hazePointer->getHazeParametersBuffer());
|
|
}
|
|
}
|
|
|
|
batch.draw(gpu::TRIANGLE_STRIP, 4);
|
|
|
|
deferredLightingEffect->unsetKeyLightBatch(batch);
|
|
batch.setResourceTexture(ru::Texture::Shadow, nullptr);
|
|
}
|
|
}
|
|
|
|
RenderDeferredLocals::RenderDeferredLocals() :
|
|
_localLightsBuffer(std::make_shared<gpu::Buffer>()) {
|
|
|
|
}
|
|
|
|
void RenderDeferredLocals::run(const render::RenderContextPointer& renderContext,
|
|
const DeferredFrameTransformPointer& frameTransform,
|
|
const DeferredFramebufferPointer& deferredFramebuffer,
|
|
const LightingModelPointer& lightingModel,
|
|
const SurfaceGeometryFramebufferPointer& surfaceGeometryFramebuffer,
|
|
const LightClustersPointer& lightClusters) {
|
|
|
|
bool points = lightingModel->isPointLightEnabled();
|
|
bool spots = lightingModel->isSpotLightEnabled();
|
|
|
|
if (!points && !spots) {
|
|
return;
|
|
}
|
|
auto args = renderContext->args;
|
|
auto& batch = (*args->_batch);
|
|
{
|
|
// THe main viewport is assumed to be the mono viewport (or the 2 stereo faces side by side within that viewport)
|
|
auto viewport = args->_viewport;
|
|
|
|
// The view frustum is the mono frustum base
|
|
auto viewFrustum = args->getViewFrustum();
|
|
|
|
// Eval the mono projection
|
|
mat4 projMat;
|
|
viewFrustum.evalProjectionMatrix(projMat);
|
|
|
|
// The view transform
|
|
Transform viewTransform;
|
|
viewFrustum.evalViewTransform(viewTransform);
|
|
|
|
|
|
auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
|
|
|
|
// Render in this viewport
|
|
batch.setViewportTransform(viewport);
|
|
batch.setStateScissorRect(viewport);
|
|
|
|
auto& lightIndices = lightClusters->_visibleLightIndices;
|
|
if (!lightIndices.empty() && lightIndices[0] > 0) {
|
|
deferredLightingEffect->setupLocalLightsBatch(batch, lightClusters);
|
|
|
|
// Local light pipeline
|
|
batch.setPipeline(deferredLightingEffect->_localLight);
|
|
|
|
batch.draw(gpu::TRIANGLE_STRIP, 4);
|
|
|
|
// Draw outline as well ?
|
|
if (lightingModel->isShowLightContourEnabled()) {
|
|
batch.setPipeline(deferredLightingEffect->_localLightOutline);
|
|
|
|
batch.draw(gpu::TRIANGLE_STRIP, 4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderDeferredCleanup::run(const render::RenderContextPointer& renderContext) {
|
|
auto args = renderContext->args;
|
|
auto& batch = (*args->_batch);
|
|
{
|
|
// Probably not necessary in the long run because the gpu layer would unbound this texture if used as render target
|
|
batch.setResourceTexture(ru::Texture::DeferredColor, nullptr);
|
|
batch.setResourceTexture(ru::Texture::DeferredNormal, nullptr);
|
|
batch.setResourceTexture(ru::Texture::DeferredSpecular, nullptr);
|
|
batch.setResourceTexture(ru::Texture::DeferredDepth, nullptr);
|
|
batch.setResourceTexture(ru::Texture::DeferredObscurance, nullptr);
|
|
|
|
batch.setResourceTexture(ru::Texture::DeferredLinearZEye, nullptr);
|
|
batch.setResourceTexture(ru::Texture::DeferredCurvature, nullptr);
|
|
batch.setResourceTexture(ru::Texture::DeferredDiffusedCurvature, nullptr);
|
|
batch.setResourceTexture(ru::Texture::SsscLut, nullptr);
|
|
batch.setResourceTexture(ru::Texture::SsscSpecularBeckmann, nullptr);
|
|
|
|
batch.setUniformBuffer(ru::Buffer::SsscParams, nullptr);
|
|
// batch.setUniformBuffer(LIGHTING_MODEL_BUFFER_SLOT, nullptr);
|
|
batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, nullptr);
|
|
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterFrustumGrid, nullptr);
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterGrid, nullptr);
|
|
batch.setUniformBuffer(ru::Buffer::LightClusterContent, nullptr);
|
|
|
|
}
|
|
}
|
|
|
|
RenderDeferred::RenderDeferred() {
|
|
DependencyManager::get<DeferredLightingEffect>()->init();
|
|
}
|
|
|
|
void RenderDeferred::configure(const Config& config) {
|
|
}
|
|
|
|
void RenderDeferred::run(const RenderContextPointer& renderContext, const Inputs& inputs) {
|
|
auto args = renderContext->args;
|
|
|
|
auto deferredTransform = inputs.get0();
|
|
auto deferredFramebuffer = inputs.get1();
|
|
auto extraRenderBuffers = inputs.get2();
|
|
auto surfaceGeometryFramebuffer = extraRenderBuffers.get0();
|
|
auto ssaoFramebuffer = extraRenderBuffers.get1();
|
|
auto subsurfaceScatteringResource = extraRenderBuffers.get2();
|
|
|
|
auto lightingModel = inputs.get3();
|
|
auto lightClusters = inputs.get4();
|
|
|
|
const auto& lightFrame = inputs.get5();
|
|
const auto& shadowFrame = inputs.get6();
|
|
const auto& hazeFrame = inputs.get7();
|
|
|
|
if (!_gpuTimer) {
|
|
_gpuTimer = std::make_shared < gpu::RangeTimer>(__FUNCTION__);
|
|
}
|
|
|
|
auto previousBatch = args->_batch;
|
|
gpu::doInBatch(nullptr, args->_context, [&](gpu::Batch& batch) {
|
|
args->_batch = &batch;
|
|
_gpuTimer->begin(batch);
|
|
|
|
setupJob.run(renderContext, deferredTransform, deferredFramebuffer, lightingModel, lightFrame, shadowFrame, hazeFrame, surfaceGeometryFramebuffer, ssaoFramebuffer, subsurfaceScatteringResource);
|
|
|
|
lightsJob.run(renderContext, deferredTransform, deferredFramebuffer, lightingModel, surfaceGeometryFramebuffer, lightClusters);
|
|
|
|
cleanupJob.run(renderContext);
|
|
|
|
_gpuTimer->end(batch);
|
|
});
|
|
args->_batch = previousBatch;
|
|
|
|
auto config = std::static_pointer_cast<Config>(renderContext->jobConfig);
|
|
config->setGPUBatchRunTime(_gpuTimer->getGPUAverage(), _gpuTimer->getBatchAverage());
|
|
}
|
|
|
|
void DefaultLightingSetup::run(const RenderContextPointer& renderContext) {
|
|
|
|
if (!_defaultLight || !_defaultBackground) {
|
|
auto defaultSkyboxURL = PathUtils::resourcesUrl() + "images/Default-Sky-9-cubemap/Default-Sky-9-cubemap.texmeta.json";
|
|
auto defaultAmbientURL = PathUtils::resourcesUrl() + "images/Default-Sky-9-cubemap/Default-Sky-9-cubemap-ambient.texmeta.json";
|
|
|
|
if (!_defaultSkyboxNetworkTexture) {
|
|
PROFILE_RANGE(render, "Process Default Skybox");
|
|
_defaultSkyboxNetworkTexture = DependencyManager::get<TextureCache>()->getTexture(
|
|
defaultSkyboxURL, image::TextureUsage::SKY_TEXTURE);
|
|
}
|
|
|
|
if (!_defaultAmbientNetworkTexture) {
|
|
PROFILE_RANGE(render, "Process Default Ambient map");
|
|
_defaultAmbientNetworkTexture = DependencyManager::get<TextureCache>()->getTexture(
|
|
defaultAmbientURL, image::TextureUsage::AMBIENT_TEXTURE);
|
|
}
|
|
|
|
if (_defaultSkyboxNetworkTexture && _defaultSkyboxNetworkTexture->isLoaded() && _defaultSkyboxNetworkTexture->getGPUTexture()) {
|
|
_defaultSkybox->setCubemap(_defaultSkyboxNetworkTexture->getGPUTexture());
|
|
} else {
|
|
// Don't do anything until the skybox has loaded
|
|
return;
|
|
}
|
|
|
|
if (_defaultAmbientNetworkTexture && _defaultAmbientNetworkTexture->isLoaded() && _defaultAmbientNetworkTexture->getGPUTexture()) {
|
|
_defaultAmbientTexture = _defaultAmbientNetworkTexture->getGPUTexture();
|
|
} else {
|
|
// Don't do anything until the ambient box has been loaded
|
|
return;
|
|
}
|
|
|
|
auto lightStage = renderContext->_scene->getStage<LightStage>();
|
|
if (lightStage) {
|
|
|
|
// Allocate a default global light directional and ambient
|
|
auto lp = std::make_shared<graphics::Light>();
|
|
lp->setType(graphics::Light::SUN);
|
|
lp->setDirection(glm::vec3(-1.0f));
|
|
lp->setColor(glm::vec3(1.0f));
|
|
lp->setIntensity(1.0f);
|
|
lp->setType(graphics::Light::SUN);
|
|
lp->setAmbientSpherePreset(gpu::SphericalHarmonics::Preset::OLD_TOWN_SQUARE);
|
|
|
|
lp->setAmbientIntensity(0.5f);
|
|
lp->setAmbientMap(_defaultAmbientTexture);
|
|
auto irradianceSH = _defaultAmbientTexture->getIrradiance();
|
|
if (irradianceSH) {
|
|
lp->setAmbientSphere((*irradianceSH));
|
|
}
|
|
|
|
// capture default light
|
|
_defaultLight = lp;
|
|
|
|
// Add the global light to the light stage (for later shadow rendering)
|
|
// Set this light to be the default
|
|
_defaultLightID = lightStage->addLight(lp, true);
|
|
}
|
|
|
|
auto backgroundStage = renderContext->_scene->getStage<BackgroundStage>();
|
|
if (backgroundStage) {
|
|
|
|
auto background = std::make_shared<graphics::SunSkyStage>();
|
|
background->setSkybox(_defaultSkybox);
|
|
|
|
// capture deault background
|
|
_defaultBackground = background;
|
|
|
|
// Add the global light to the light stage (for later shadow rendering)
|
|
_defaultBackgroundID = backgroundStage->addBackground(_defaultBackground);
|
|
}
|
|
}
|
|
|
|
if (!_defaultHaze) {
|
|
auto hazeStage = renderContext->_scene->getStage<HazeStage>();
|
|
if (hazeStage) {
|
|
auto haze = std::make_shared<graphics::Haze>();
|
|
|
|
_defaultHaze = haze;
|
|
_defaultHazeID = hazeStage->addHaze(_defaultHaze);
|
|
}
|
|
}
|
|
}
|
|
|