mirror of
https://thingvellir.net/git/overte
synced 2025-03-27 23:52:03 +01:00
1021 lines
43 KiB
C++
1021 lines
43 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 this before QOpenGLFramebufferObject, which includes an earlier version of OpenGL
|
|
#include <gpu/GPUConfig.h>
|
|
|
|
#include <GLMHelpers.h>
|
|
#include <PathUtils.h>
|
|
#include <ViewFrustum.h>
|
|
|
|
#include "AbstractViewStateInterface.h"
|
|
#include "DeferredLightingEffect.h"
|
|
#include "GeometryCache.h"
|
|
#include "GlowEffect.h"
|
|
#include "RenderUtil.h"
|
|
#include "TextureCache.h"
|
|
|
|
#include "gpu/Batch.h"
|
|
#include "gpu/GLBackend.h"
|
|
#include "gpu/StandardShaderLib.h"
|
|
|
|
#include "simple_vert.h"
|
|
#include "simple_frag.h"
|
|
#include "simple_textured_frag.h"
|
|
|
|
#include "deferred_light_vert.h"
|
|
#include "deferred_light_limited_vert.h"
|
|
|
|
#include "directional_light_frag.h"
|
|
#include "directional_light_shadow_map_frag.h"
|
|
#include "directional_light_cascaded_shadow_map_frag.h"
|
|
|
|
#include "directional_ambient_light_frag.h"
|
|
#include "directional_ambient_light_shadow_map_frag.h"
|
|
#include "directional_ambient_light_cascaded_shadow_map_frag.h"
|
|
|
|
#include "directional_skybox_light_frag.h"
|
|
#include "directional_skybox_light_shadow_map_frag.h"
|
|
#include "directional_skybox_light_cascaded_shadow_map_frag.h"
|
|
|
|
#include "point_light_frag.h"
|
|
#include "spot_light_frag.h"
|
|
|
|
static const std::string glowIntensityShaderHandle = "glowIntensity";
|
|
|
|
void DeferredLightingEffect::init(AbstractViewStateInterface* viewState) {
|
|
auto VS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(simple_vert)));
|
|
auto PS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(simple_frag)));
|
|
auto PSTextured = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(simple_textured_frag)));
|
|
|
|
gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(VS, PS));
|
|
gpu::ShaderPointer programTextured = gpu::ShaderPointer(gpu::Shader::createProgram(VS, PSTextured));
|
|
|
|
gpu::Shader::BindingSet slotBindings;
|
|
gpu::Shader::makeProgram(*program, slotBindings);
|
|
gpu::Shader::makeProgram(*programTextured, slotBindings);
|
|
|
|
gpu::StatePointer state = gpu::StatePointer(new gpu::State());
|
|
state->setCullMode(gpu::State::CULL_BACK);
|
|
state->setDepthTest(true, true, gpu::LESS_EQUAL);
|
|
state->setBlendFunction(false,
|
|
gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
|
|
gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
|
|
|
|
|
|
gpu::StatePointer stateCullNone = gpu::StatePointer(new gpu::State());
|
|
stateCullNone->setCullMode(gpu::State::CULL_NONE);
|
|
stateCullNone->setDepthTest(true, true, gpu::LESS_EQUAL);
|
|
stateCullNone->setBlendFunction(false,
|
|
gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
|
|
gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
|
|
|
|
_simpleProgram = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
|
|
_simpleProgramCullNone = gpu::PipelinePointer(gpu::Pipeline::create(program, stateCullNone));
|
|
_simpleProgramTextured = gpu::PipelinePointer(gpu::Pipeline::create(programTextured, state));
|
|
_simpleProgramTexturedCullNone = gpu::PipelinePointer(gpu::Pipeline::create(programTextured, stateCullNone));
|
|
|
|
_viewState = viewState;
|
|
loadLightProgram(directional_light_frag, false, _directionalLight, _directionalLightLocations);
|
|
loadLightProgram(directional_light_shadow_map_frag, false, _directionalLightShadowMap,
|
|
_directionalLightShadowMapLocations);
|
|
loadLightProgram(directional_light_cascaded_shadow_map_frag, false, _directionalLightCascadedShadowMap,
|
|
_directionalLightCascadedShadowMapLocations);
|
|
|
|
loadLightProgram(directional_ambient_light_frag, false, _directionalAmbientSphereLight, _directionalAmbientSphereLightLocations);
|
|
loadLightProgram(directional_ambient_light_shadow_map_frag, false, _directionalAmbientSphereLightShadowMap,
|
|
_directionalAmbientSphereLightShadowMapLocations);
|
|
loadLightProgram(directional_ambient_light_cascaded_shadow_map_frag, false, _directionalAmbientSphereLightCascadedShadowMap,
|
|
_directionalAmbientSphereLightCascadedShadowMapLocations);
|
|
|
|
loadLightProgram(directional_skybox_light_frag, false, _directionalSkyboxLight, _directionalSkyboxLightLocations);
|
|
loadLightProgram(directional_skybox_light_shadow_map_frag, false, _directionalSkyboxLightShadowMap,
|
|
_directionalSkyboxLightShadowMapLocations);
|
|
loadLightProgram(directional_skybox_light_cascaded_shadow_map_frag, false, _directionalSkyboxLightCascadedShadowMap,
|
|
_directionalSkyboxLightCascadedShadowMapLocations);
|
|
|
|
loadLightProgram(point_light_frag, true, _pointLight, _pointLightLocations);
|
|
loadLightProgram(spot_light_frag, true, _spotLight, _spotLightLocations);
|
|
|
|
{
|
|
auto VSFS = gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS();
|
|
auto PSBlit = gpu::StandardShaderLib::getDrawTexturePS();
|
|
auto blitProgram = gpu::ShaderPointer(gpu::Shader::createProgram(VSFS, PSBlit));
|
|
gpu::Shader::makeProgram(*blitProgram);
|
|
gpu::StatePointer blitState = gpu::StatePointer(new gpu::State());
|
|
blitState->setBlendFunction(true,
|
|
gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
|
|
gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
|
|
blitState->setColorWriteMask(true, true, true, false);
|
|
_blitLightBuffer = gpu::PipelinePointer(gpu::Pipeline::create(blitProgram, blitState));
|
|
}
|
|
|
|
// Allocate a global light representing the Global Directional light casting shadow (the sun) and the ambient light
|
|
_globalLights.push_back(0);
|
|
_allocatedLights.push_back(model::LightPointer(new model::Light()));
|
|
|
|
model::LightPointer lp = _allocatedLights[0];
|
|
|
|
lp->setDirection(-glm::vec3(1.0f, 1.0f, 1.0f));
|
|
lp->setColor(glm::vec3(1.0f));
|
|
lp->setIntensity(1.0f);
|
|
lp->setType(model::Light::SUN);
|
|
lp->setAmbientSpherePreset(gpu::SphericalHarmonics::Preset(_ambientLightMode % gpu::SphericalHarmonics::NUM_PRESET));
|
|
}
|
|
|
|
void DeferredLightingEffect::bindSimpleProgram(gpu::Batch& batch, bool textured, bool culled) {
|
|
// DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers(batch, true, true, true);
|
|
|
|
if (textured) {
|
|
if (culled) {
|
|
batch.setPipeline(_simpleProgramTextured);
|
|
} else {
|
|
batch.setPipeline(_simpleProgramTexturedCullNone);
|
|
}
|
|
} else {
|
|
if (culled) {
|
|
batch.setPipeline(_simpleProgram);
|
|
} else {
|
|
batch.setPipeline(_simpleProgramCullNone);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DeferredLightingEffect::releaseSimpleProgram(gpu::Batch& batch) {
|
|
// DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers(batch, true, false, false);
|
|
}
|
|
|
|
void DeferredLightingEffect::renderSolidSphere(gpu::Batch& batch, float radius, int slices, int stacks, const glm::vec4& color) {
|
|
bindSimpleProgram(batch);
|
|
DependencyManager::get<GeometryCache>()->renderSphere(batch, radius, slices, stacks, color);
|
|
releaseSimpleProgram(batch);
|
|
}
|
|
|
|
void DeferredLightingEffect::renderWireSphere(gpu::Batch& batch, float radius, int slices, int stacks, const glm::vec4& color) {
|
|
bindSimpleProgram(batch);
|
|
DependencyManager::get<GeometryCache>()->renderSphere(batch, radius, slices, stacks, color, false);
|
|
releaseSimpleProgram(batch);
|
|
}
|
|
|
|
void DeferredLightingEffect::renderSolidCube(gpu::Batch& batch, float size, const glm::vec4& color) {
|
|
bindSimpleProgram(batch);
|
|
DependencyManager::get<GeometryCache>()->renderSolidCube(batch, size, color);
|
|
releaseSimpleProgram(batch);
|
|
}
|
|
|
|
void DeferredLightingEffect::renderWireCube(gpu::Batch& batch, float size, const glm::vec4& color) {
|
|
bindSimpleProgram(batch);
|
|
DependencyManager::get<GeometryCache>()->renderWireCube(batch, size, color);
|
|
releaseSimpleProgram(batch);
|
|
}
|
|
|
|
void DeferredLightingEffect::renderQuad(gpu::Batch& batch, const glm::vec3& minCorner, const glm::vec3& maxCorner,
|
|
const glm::vec4& color) {
|
|
bindSimpleProgram(batch);
|
|
DependencyManager::get<GeometryCache>()->renderQuad(batch, minCorner, maxCorner, color);
|
|
releaseSimpleProgram(batch);
|
|
}
|
|
|
|
void DeferredLightingEffect::renderLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2,
|
|
const glm::vec4& color1, const glm::vec4& color2) {
|
|
bindSimpleProgram(batch);
|
|
DependencyManager::get<GeometryCache>()->renderLine(batch, p1, p2, color1, color2);
|
|
releaseSimpleProgram(batch);
|
|
}
|
|
|
|
void DeferredLightingEffect::addPointLight(const glm::vec3& position, float radius, const glm::vec3& color,
|
|
float intensity) {
|
|
addSpotLight(position, radius, color, intensity);
|
|
}
|
|
|
|
void DeferredLightingEffect::addSpotLight(const glm::vec3& position, float radius, const glm::vec3& color,
|
|
float intensity, const glm::quat& orientation, float exponent, float cutoff) {
|
|
|
|
unsigned int lightID = _pointLights.size() + _spotLights.size() + _globalLights.size();
|
|
if (lightID >= _allocatedLights.size()) {
|
|
_allocatedLights.push_back(model::LightPointer(new model::Light()));
|
|
}
|
|
model::LightPointer lp = _allocatedLights[lightID];
|
|
|
|
lp->setPosition(position);
|
|
lp->setMaximumRadius(radius);
|
|
lp->setColor(color);
|
|
lp->setIntensity(intensity);
|
|
//lp->setShowContour(quadraticAttenuation);
|
|
|
|
if (exponent == 0.0f && cutoff == PI) {
|
|
lp->setType(model::Light::POINT);
|
|
_pointLights.push_back(lightID);
|
|
|
|
} else {
|
|
lp->setOrientation(orientation);
|
|
lp->setSpotAngle(cutoff);
|
|
lp->setSpotExponent(exponent);
|
|
lp->setType(model::Light::SPOT);
|
|
_spotLights.push_back(lightID);
|
|
}
|
|
}
|
|
|
|
void DeferredLightingEffect::prepare(RenderArgs* args) {
|
|
|
|
auto textureCache = DependencyManager::get<TextureCache>();
|
|
gpu::Batch batch;
|
|
// batch.setFramebuffer(textureCache->getPrimaryFramebuffer());
|
|
|
|
// clear the normal and specular buffers
|
|
batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR1, glm::vec4(0.0f, 0.0f, 0.0f, 0.0f));
|
|
const float MAX_SPECULAR_EXPONENT = 128.0f;
|
|
batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR2, glm::vec4(0.0f, 0.0f, 0.0f, 1.0f / MAX_SPECULAR_EXPONENT));
|
|
|
|
args->_context->syncCache();
|
|
args->_context->render(batch);
|
|
/*
|
|
textureCache->setPrimaryDrawBuffers(false, true, false);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
textureCache->setPrimaryDrawBuffers(false, false, true);
|
|
// clearing to zero alpha for specular causes problems on my Nvidia card; clear to lowest non-zero value instead
|
|
const float MAX_SPECULAR_EXPONENT = 128.0f;
|
|
glClearColor(0.0f, 0.0f, 0.0f, 1.0f / MAX_SPECULAR_EXPONENT);
|
|
glClear(GL_COLOR_BUFFER_BIT);*/
|
|
/* glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
textureCache->setPrimaryDrawBuffers(true, false, false);
|
|
*/}
|
|
|
|
void DeferredLightingEffect::render(RenderArgs* args) {
|
|
gpu::Batch batch;
|
|
|
|
// perform deferred lighting, rendering to free fbo
|
|
/* glDisable(GL_BLEND);
|
|
glDisable(GL_LIGHTING);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glDisable(GL_COLOR_MATERIAL);
|
|
glDepthMask(false);
|
|
*/
|
|
auto textureCache = DependencyManager::get<TextureCache>();
|
|
|
|
// glBindFramebuffer(GL_FRAMEBUFFER, 0 );
|
|
|
|
QSize framebufferSize = textureCache->getFrameBufferSize();
|
|
|
|
// binding the first framebuffer
|
|
auto freeFBO = DependencyManager::get<GlowEffect>()->getFreeFramebuffer();
|
|
|
|
batch.setFramebuffer(freeFBO);
|
|
|
|
//glBindFramebuffer(GL_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(freeFBO));
|
|
|
|
batch.clearColorFramebuffer(freeFBO->getBufferMask(), glm::vec4(0.0f, 0.0f, 0.0f, 0.0f));
|
|
|
|
// glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
// glBindTexture(GL_TEXTURE_2D, primaryFBO->texture());
|
|
// glBindTexture(GL_TEXTURE_2D, textureCache->getPrimaryColorTextureID());
|
|
|
|
batch.setUniformTexture(0, textureCache->getPrimaryColorTexture());
|
|
|
|
// glActiveTexture(GL_TEXTURE1);
|
|
// glBindTexture(GL_TEXTURE_2D, textureCache->getPrimaryNormalTextureID());
|
|
batch.setUniformTexture(1, textureCache->getPrimaryNormalTexture());
|
|
|
|
// glActiveTexture(GL_TEXTURE2);
|
|
// glBindTexture(GL_TEXTURE_2D, textureCache->getPrimarySpecularTextureID());
|
|
batch.setUniformTexture(2, textureCache->getPrimarySpecularTexture());
|
|
|
|
// glActiveTexture(GL_TEXTURE3);
|
|
// glBindTexture(GL_TEXTURE_2D, textureCache->getPrimaryDepthTextureID());
|
|
batch.setUniformTexture(3, textureCache->getPrimaryDepthTexture());
|
|
|
|
// get the viewport side (left, right, both)
|
|
int viewport[4];
|
|
glGetIntegerv(GL_VIEWPORT, viewport);
|
|
const int VIEWPORT_X_INDEX = 0;
|
|
const int VIEWPORT_Y_INDEX = 1;
|
|
const int VIEWPORT_WIDTH_INDEX = 2;
|
|
const int VIEWPORT_HEIGHT_INDEX = 3;
|
|
|
|
float sMin = viewport[VIEWPORT_X_INDEX] / (float)framebufferSize.width();
|
|
float sWidth = viewport[VIEWPORT_WIDTH_INDEX] / (float)framebufferSize.width();
|
|
float tMin = viewport[VIEWPORT_Y_INDEX] / (float)framebufferSize.height();
|
|
float tHeight = viewport[VIEWPORT_HEIGHT_INDEX] / (float)framebufferSize.height();
|
|
|
|
bool useSkyboxCubemap = (_skybox) && (_skybox->getCubemap());
|
|
|
|
// Fetch the ViewMatrix;
|
|
glm::mat4 invViewMat;
|
|
_viewState->getViewTransform().getMatrix(invViewMat);
|
|
|
|
// ProgramObject* program = &_directionalLight;
|
|
auto& program = _directionalLight;
|
|
const LightLocations* locations = &_directionalLightLocations;
|
|
bool shadowsEnabled = _viewState->getShadowsEnabled();
|
|
if (shadowsEnabled) {
|
|
|
|
// glActiveTexture(GL_TEXTURE4);
|
|
// glBindTexture(GL_TEXTURE_2D, textureCache->getShadowDepthTextureID());
|
|
batch.setUniformTexture(4, textureCache->getShadowFramebuffer()->getDepthStencilBuffer());
|
|
|
|
program = _directionalLightShadowMap;
|
|
locations = &_directionalLightShadowMapLocations;
|
|
if (_viewState->getCascadeShadowsEnabled()) {
|
|
program = _directionalLightCascadedShadowMap;
|
|
locations = &_directionalLightCascadedShadowMapLocations;
|
|
if (useSkyboxCubemap) {
|
|
program = _directionalSkyboxLightCascadedShadowMap;
|
|
locations = &_directionalSkyboxLightCascadedShadowMapLocations;
|
|
} else if (_ambientLightMode > -1) {
|
|
program = _directionalAmbientSphereLightCascadedShadowMap;
|
|
locations = &_directionalAmbientSphereLightCascadedShadowMapLocations;
|
|
}
|
|
batch.setPipeline(program);
|
|
//program->bind();
|
|
// program->setUniform(locations->shadowDistances, _viewState->getShadowDistances());
|
|
batch._glUniform3fv(locations->shadowDistances, 1, (const GLfloat*) &_viewState->getShadowDistances());
|
|
|
|
} else {
|
|
if (useSkyboxCubemap) {
|
|
program = _directionalSkyboxLightShadowMap;
|
|
locations = &_directionalSkyboxLightShadowMapLocations;
|
|
} else if (_ambientLightMode > -1) {
|
|
program = _directionalAmbientSphereLightShadowMap;
|
|
locations = &_directionalAmbientSphereLightShadowMapLocations;
|
|
}
|
|
batch.setPipeline(program);
|
|
}
|
|
// program->setUniformValue(locations->shadowScale, 1.0f / textureCache->getShadowFramebuffer()->getWidth());
|
|
batch._glUniform1f(locations->shadowScale, 1.0f / textureCache->getShadowFramebuffer()->getWidth());
|
|
|
|
} else {
|
|
if (useSkyboxCubemap) {
|
|
program = _directionalSkyboxLight;
|
|
locations = &_directionalSkyboxLightLocations;
|
|
} else if (_ambientLightMode > -1) {
|
|
program = _directionalAmbientSphereLight;
|
|
locations = &_directionalAmbientSphereLightLocations;
|
|
}
|
|
batch.setPipeline(program);
|
|
}
|
|
|
|
{
|
|
auto globalLight = _allocatedLights[_globalLights.front()];
|
|
|
|
if (locations->ambientSphere >= 0) {
|
|
gpu::SphericalHarmonics sh = globalLight->getAmbientSphere();
|
|
if (useSkyboxCubemap && _skybox->getCubemap()->getIrradiance()) {
|
|
sh = (*_skybox->getCubemap()->getIrradiance());
|
|
}
|
|
// batch._glUniform4fv(locations->ambientSphere, gpu::SphericalHarmonics::NUM_COEFFICIENTS, (const GLfloat*) (&sh));
|
|
|
|
for (int i =0; i <gpu::SphericalHarmonics::NUM_COEFFICIENTS; i++) {
|
|
batch._glUniform4fv(locations->ambientSphere + i, 1, (const GLfloat*) (&sh) + i * 4);
|
|
}
|
|
/* for (int i =0; i <gpu::SphericalHarmonics::NUM_COEFFICIENTS; i++) {
|
|
program->setUniformValue(locations->ambientSphere + i, *(((QVector4D*) &sh) + i));
|
|
}*/
|
|
}
|
|
|
|
if (useSkyboxCubemap) {
|
|
// glActiveTexture(GL_TEXTURE5);
|
|
// glBindTexture(GL_TEXTURE_CUBE_MAP, gpu::GLBackend::getTextureID(_skybox->getCubemap()));
|
|
batch.setUniformTexture(5, _skybox->getCubemap());
|
|
}
|
|
|
|
if (locations->lightBufferUnit >= 0) {
|
|
//gpu::Batch batch;
|
|
batch.setUniformBuffer(locations->lightBufferUnit, globalLight->getSchemaBuffer());
|
|
//gpu::GLBackend::renderBatch(batch);
|
|
}
|
|
|
|
if (_atmosphere && (locations->atmosphereBufferUnit >= 0)) {
|
|
//gpu::Batch batch;
|
|
batch.setUniformBuffer(locations->atmosphereBufferUnit, _atmosphere->getDataBuffer());
|
|
//gpu::GLBackend::renderBatch(batch);
|
|
}
|
|
// glUniformMatrix4fv(locations->invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
|
|
batch._glUniformMatrix4fv(locations->invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
|
|
}
|
|
|
|
float left, right, bottom, top, nearVal, farVal;
|
|
glm::vec4 nearClipPlane, farClipPlane;
|
|
_viewState->computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
|
|
// program->setUniformValue(locations->nearLocation, nearVal);
|
|
batch._glUniform1f(locations->nearLocation, nearVal);
|
|
|
|
float depthScale = (farVal - nearVal) / farVal;
|
|
// program->setUniformValue(locations->depthScale, depthScale);
|
|
batch._glUniform1f(locations->depthScale, depthScale);
|
|
|
|
float nearScale = -1.0f / nearVal;
|
|
float depthTexCoordScaleS = (right - left) * nearScale / sWidth;
|
|
float depthTexCoordScaleT = (top - bottom) * nearScale / tHeight;
|
|
float depthTexCoordOffsetS = left * nearScale - sMin * depthTexCoordScaleS;
|
|
float depthTexCoordOffsetT = bottom * nearScale - tMin * depthTexCoordScaleT;
|
|
// program->setUniformValue(locations->depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
|
|
// program->setUniformValue(locations->depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
|
|
batch._glUniform2f(locations->depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
|
|
batch._glUniform2f(locations->depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
|
|
|
|
Transform model;
|
|
model.setTranslation(glm::vec3(sMin, tMin, 0.0));
|
|
model.setScale(glm::vec3(sWidth, tHeight, 1.0));
|
|
batch.setModelTransform(model);
|
|
|
|
batch.setProjectionTransform(glm::mat4());
|
|
batch.setViewTransform(Transform());
|
|
|
|
{
|
|
glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
|
|
glm::vec2 topLeft(-1.0f, -1.0f);
|
|
glm::vec2 bottomRight(1.0f, 1.0f);
|
|
glm::vec2 texCoordTopLeft(sMin, tMin);
|
|
glm::vec2 texCoordBottomRight(sMin + sWidth, tMin + tHeight);
|
|
|
|
DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
|
|
}
|
|
|
|
// renderFullscreenQuad(sMin, sMin + sWidth, tMin, tMin + tHeight);
|
|
// batch.draw(gpu::TRIANGLE_STRIP, 4); // full screen quad
|
|
|
|
// args->_context->syncCache();
|
|
// args->_context->render(batch);
|
|
//program->release();
|
|
|
|
if (useSkyboxCubemap) {
|
|
batch.setUniformTexture(5, nullptr);
|
|
|
|
// glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
|
|
// if (!shadowsEnabled) {
|
|
// glActiveTexture(GL_TEXTURE3);
|
|
// }
|
|
}
|
|
|
|
if (shadowsEnabled) {
|
|
batch.setUniformTexture(4, nullptr);
|
|
// glBindTexture(GL_TEXTURE_2D, 0);
|
|
// glActiveTexture(GL_TEXTURE3);
|
|
}
|
|
|
|
|
|
// additive blending
|
|
// glEnable(GL_BLEND);
|
|
// glBlendFunc(GL_ONE, GL_ONE);
|
|
|
|
// glEnable(GL_CULL_FACE);
|
|
|
|
|
|
glm::vec4 sCoefficients(sWidth / 2.0f, 0.0f, 0.0f, sMin + sWidth / 2.0f);
|
|
glm::vec4 tCoefficients(0.0f, tHeight / 2.0f, 0.0f, tMin + tHeight / 2.0f);
|
|
// glTexGenfv(GL_S, GL_OBJECT_PLANE, (const GLfloat*)&sCoefficients);
|
|
// glTexGenfv(GL_T, GL_OBJECT_PLANE, (const GLfloat*)&tCoefficients);
|
|
// texcoordMat
|
|
auto texcoordMat = glm::mat4();
|
|
texcoordMat[0] = glm::vec4(sWidth / 2.0f, 0.0f, 0.0f, sMin + sWidth / 2.0f);
|
|
texcoordMat[1] = glm::vec4(0.0f, tHeight / 2.0f, 0.0f, tMin + tHeight / 2.0f);
|
|
texcoordMat[2] = glm::vec4(0.0f, 0.0f, 1.0f, 0.0f);
|
|
texcoordMat[3] = glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
|
|
|
|
// enlarge the scales slightly to account for tesselation
|
|
const float SCALE_EXPANSION = 0.05f;
|
|
|
|
const glm::vec3& eyePoint = _viewState->getCurrentViewFrustum()->getPosition();
|
|
float nearRadius = glm::distance(eyePoint, _viewState->getCurrentViewFrustum()->getNearTopLeft());
|
|
|
|
auto geometryCache = DependencyManager::get<GeometryCache>();
|
|
|
|
glm::mat4 projMat;
|
|
Transform viewMat;
|
|
args->_viewFrustum->evalProjectionMatrix(projMat);
|
|
args->_viewFrustum->evalViewTransform(viewMat);
|
|
if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
|
|
viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
|
|
}
|
|
batch.setProjectionTransform(projMat);
|
|
batch.setViewTransform(viewMat);
|
|
|
|
if (!_pointLights.empty()) {
|
|
batch.setPipeline(_pointLight);
|
|
batch._glUniform1f(_pointLightLocations.nearLocation, nearVal);
|
|
batch._glUniform1f(_pointLightLocations.depthScale, depthScale);
|
|
batch._glUniform2f(_pointLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
|
|
batch._glUniform2f(_pointLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
|
|
|
|
//_pointLight.bind();
|
|
//_pointLight.setUniformValue(_pointLightLocations.nearLocation, nearVal);
|
|
//_pointLight.setUniformValue(_pointLightLocations.depthScale, depthScale);
|
|
//_pointLight.setUniformValue(_pointLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
|
|
//_pointLight.setUniformValue(_pointLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
|
|
|
|
batch._glUniformMatrix4fv(_pointLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
|
|
|
|
//glUniformMatrix4fv(_pointLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
|
|
batch._glUniformMatrix4fv(_pointLightLocations.texcoordMat, 1, false, reinterpret_cast< const GLfloat* >(&texcoordMat));
|
|
|
|
for (auto lightID : _pointLights) {
|
|
auto& light = _allocatedLights[lightID];
|
|
light->setShowContour(true);
|
|
if (_pointLightLocations.lightBufferUnit >= 0) {
|
|
// gpu::Batch batch;
|
|
batch.setUniformBuffer(_pointLightLocations.lightBufferUnit, light->getSchemaBuffer());
|
|
// gpu::GLBackend::renderBatch(batch);
|
|
}
|
|
|
|
|
|
// glPushMatrix();
|
|
|
|
float expandedRadius = light->getMaximumRadius() * (1.0f + SCALE_EXPANSION);
|
|
if (glm::distance(eyePoint, glm::vec3(light->getPosition())) < expandedRadius + nearRadius) {
|
|
|
|
/* glLoadIdentity();
|
|
glTranslatef(0.0f, 0.0f, -1.0f);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
*/
|
|
// renderFullscreenQuad();
|
|
Transform model;
|
|
model.setTranslation(glm::vec3(0.0f, 0.0f, -1.0f));
|
|
batch.setModelTransform(model);
|
|
|
|
{
|
|
glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
|
|
glm::vec2 topLeft(-1.0f, -1.0f);
|
|
glm::vec2 bottomRight(1.0f, 1.0f);
|
|
glm::vec2 texCoordTopLeft(sMin, tMin);
|
|
glm::vec2 texCoordBottomRight(sMin + sWidth, tMin + tHeight);
|
|
|
|
DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
|
|
}
|
|
/*
|
|
glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
*/
|
|
} else {
|
|
Transform model;
|
|
model.setTranslation(glm::vec3(light->getPosition().x, light->getPosition().y, light->getPosition().z));
|
|
batch.setModelTransform(model);
|
|
// glTranslatef(light->getPosition().x, light->getPosition().y, light->getPosition().z);
|
|
|
|
// geometryCache->renderSphere(expandedRadius, 32, 32, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
|
|
geometryCache->renderSphere(batch, expandedRadius, 32, 32, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
|
|
}
|
|
|
|
// glPopMatrix();
|
|
}
|
|
_pointLights.clear();
|
|
|
|
// _pointLight.release();
|
|
}
|
|
|
|
if (!_spotLights.empty()) {
|
|
batch.setPipeline(_pointLight);
|
|
batch._glUniform1f(_spotLightLocations.nearLocation, nearVal);
|
|
batch._glUniform1f(_spotLightLocations.depthScale, depthScale);
|
|
batch._glUniform2f(_spotLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
|
|
batch._glUniform2f(_spotLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
|
|
|
|
/* _spotLight.bind();
|
|
_spotLight.setUniformValue(_spotLightLocations.nearLocation, nearVal);
|
|
_spotLight.setUniformValue(_spotLightLocations.depthScale, depthScale);
|
|
_spotLight.setUniformValue(_spotLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
|
|
_spotLight.setUniformValue(_spotLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
|
|
*/
|
|
|
|
|
|
batch._glUniformMatrix4fv(_spotLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
|
|
|
|
//glUniformMatrix4fv(_pointLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
|
|
batch._glUniformMatrix4fv(_spotLightLocations.texcoordMat, 1, false, reinterpret_cast< const GLfloat* >(&texcoordMat));
|
|
|
|
for (auto lightID : _spotLights) {
|
|
auto light = _allocatedLights[lightID];
|
|
|
|
if (_spotLightLocations.lightBufferUnit >= 0) {
|
|
// gpu::Batch batch;
|
|
batch.setUniformBuffer(_spotLightLocations.lightBufferUnit, light->getSchemaBuffer());
|
|
// gpu::GLBackend::renderBatch(batch);
|
|
}
|
|
// glUniformMatrix4fv(_spotLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
|
|
|
|
// glPushMatrix();
|
|
|
|
float expandedRadius = light->getMaximumRadius() * (1.0f + SCALE_EXPANSION);
|
|
float edgeRadius = expandedRadius / glm::cos(light->getSpotAngle());
|
|
if (glm::distance(eyePoint, glm::vec3(light->getPosition())) < edgeRadius + nearRadius) {
|
|
/*glLoadIdentity();
|
|
glTranslatef(0.0f, 0.0f, -1.0f);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
renderFullscreenQuad();*/
|
|
Transform model;
|
|
model.setTranslation(glm::vec3(0.0f, 0.0f, -1.0f));
|
|
batch.setModelTransform(model);
|
|
|
|
{
|
|
glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
|
|
glm::vec2 topLeft(-1.0f, -1.0f);
|
|
glm::vec2 bottomRight(1.0f, 1.0f);
|
|
glm::vec2 texCoordTopLeft(sMin, tMin);
|
|
glm::vec2 texCoordBottomRight(sMin + sWidth, tMin + tHeight);
|
|
|
|
DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
|
|
}
|
|
|
|
/* glPopMatrix();
|
|
glMatrixMode(GL_MODELVIEW);*/
|
|
|
|
} else {
|
|
Transform model;
|
|
model.setTranslation(glm::vec3(light->getPosition().x, light->getPosition().y, light->getPosition().z));
|
|
|
|
glm::quat spotRotation = rotationBetween(glm::vec3(0.0f, 0.0f, -1.0f), light->getDirection());
|
|
glm::vec3 axis = glm::axis(spotRotation);
|
|
|
|
model.postRotate(spotRotation);
|
|
model.postTranslate(glm::vec3(0.0f, 0.0f, -light->getMaximumRadius() * (1.0f + SCALE_EXPANSION * 0.5f)));
|
|
|
|
float base = expandedRadius * glm::tan(light->getSpotAngle());
|
|
float height = expandedRadius;
|
|
model.postScale(glm::vec3(base, base, height));
|
|
|
|
batch.setModelTransform(model);
|
|
auto mesh = getSpotLightMesh();
|
|
|
|
|
|
batch.setIndexBuffer(mesh->getIndexBuffer());
|
|
batch.setInputBuffer(0, mesh->getVertexBuffer());
|
|
batch.setInputFormat(mesh->getVertexFormat());
|
|
|
|
|
|
auto& part = mesh->getPartBuffer().get<model::Mesh::Part>();
|
|
|
|
batch.drawIndexed(model::Mesh::topologyToPrimitive(part._topology), part._numIndices, part._startIndex);
|
|
|
|
|
|
//geometryCache->renderCone(batch, expandedRadius * glm::tan(light->getSpotAngle()), expandedRadius, 32, 1);
|
|
|
|
/*
|
|
glTranslatef(light->getPosition().x, light->getPosition().y, light->getPosition().z);
|
|
glm::quat spotRotation = rotationBetween(glm::vec3(0.0f, 0.0f, -1.0f), light->getDirection());
|
|
glm::vec3 axis = glm::axis(spotRotation);
|
|
glRotatef(glm::degrees(glm::angle(spotRotation)), axis.x, axis.y, axis.z);
|
|
glTranslatef(0.0f, 0.0f, -light->getMaximumRadius() * (1.0f + SCALE_EXPANSION * 0.5f));
|
|
geometryCache->renderCone(expandedRadius * glm::tan(light->getSpotAngle()), expandedRadius, 32, 1);
|
|
*/
|
|
}
|
|
|
|
glPopMatrix();
|
|
}
|
|
_spotLights.clear();
|
|
|
|
// _spotLight.release();
|
|
}
|
|
|
|
/*
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glActiveTexture(GL_TEXTURE2);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glActiveTexture(GL_TEXTURE1);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
*/
|
|
// Probably not necessary in the long run because the gpu layer would unbound this texture if used as render target
|
|
batch.setUniformTexture(0, nullptr);
|
|
batch.setUniformTexture(1, nullptr);
|
|
batch.setUniformTexture(2, nullptr);
|
|
batch.setUniformTexture(3, nullptr);
|
|
|
|
args->_context->syncCache();
|
|
args->_context->render(batch);
|
|
|
|
// End of the Lighting pass
|
|
}
|
|
|
|
void DeferredLightingEffect::copyBack(RenderArgs* args) {
|
|
|
|
gpu::Batch batch;
|
|
|
|
auto textureCache = DependencyManager::get<TextureCache>();
|
|
QSize framebufferSize = textureCache->getFrameBufferSize();
|
|
|
|
auto freeFBO = DependencyManager::get<GlowEffect>()->getFreeFramebuffer();
|
|
|
|
//freeFBO->release();
|
|
// glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
|
|
|
|
// glDisable(GL_CULL_FACE);
|
|
|
|
// now transfer the lit region to the primary fbo
|
|
// glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
|
|
// glColorMask(true, true, true, false);
|
|
|
|
auto primaryFBO = gpu::GLBackend::getFramebufferID(textureCache->getPrimaryFramebuffer());
|
|
// glBindFramebuffer(GL_DRAW_FRAMEBUFFER, primaryFBO);
|
|
batch.setFramebuffer(textureCache->getPrimaryFramebuffer());
|
|
batch.setPipeline(_blitLightBuffer);
|
|
|
|
//primaryFBO->bind();
|
|
|
|
// glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(freeFBO->getRenderBuffer(0)));
|
|
// glEnable(GL_TEXTURE_2D);
|
|
|
|
batch.setUniformTexture(0, freeFBO->getRenderBuffer(0));
|
|
|
|
/* glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
*/
|
|
|
|
batch.setProjectionTransform(glm::mat4());
|
|
batch.setViewTransform(Transform());
|
|
|
|
int viewport[4];
|
|
glGetIntegerv(GL_VIEWPORT, viewport);
|
|
const int VIEWPORT_X_INDEX = 0;
|
|
const int VIEWPORT_Y_INDEX = 1;
|
|
const int VIEWPORT_WIDTH_INDEX = 2;
|
|
const int VIEWPORT_HEIGHT_INDEX = 3;
|
|
|
|
float sMin = viewport[VIEWPORT_X_INDEX] / (float)framebufferSize.width();
|
|
float sWidth = viewport[VIEWPORT_WIDTH_INDEX] / (float)framebufferSize.width();
|
|
float tMin = viewport[VIEWPORT_Y_INDEX] / (float)framebufferSize.height();
|
|
float tHeight = viewport[VIEWPORT_HEIGHT_INDEX] / (float)framebufferSize.height();
|
|
|
|
Transform model;
|
|
model.setTranslation(glm::vec3(sMin, tMin, 0.0));
|
|
model.setScale(glm::vec3(sWidth, tHeight, 1.0));
|
|
batch.setModelTransform(model);
|
|
|
|
|
|
batch.setViewportTransform(glm::ivec4(viewport[0], viewport[1], viewport[2], viewport[3]));
|
|
|
|
batch.draw(gpu::TRIANGLE_STRIP, 4);
|
|
|
|
|
|
args->_context->syncCache();
|
|
args->_context->render(batch);
|
|
// renderFullscreenQuad(sMin, sMin + sWidth, tMin, tMin + tHeight);
|
|
|
|
// glBindTexture(GL_TEXTURE_2D, 0);
|
|
// glDisable(GL_TEXTURE_2D);
|
|
|
|
/* glColorMask(true, true, true, true);
|
|
glEnable(GL_LIGHTING);
|
|
glEnable(GL_COLOR_MATERIAL);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDepthMask(true);
|
|
|
|
glPopMatrix();
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();*/
|
|
}
|
|
|
|
void DeferredLightingEffect::setupTransparent(RenderArgs* args, int lightBufferUnit) {
|
|
auto globalLight = _allocatedLights[_globalLights.front()];
|
|
args->_batch->setUniformBuffer(lightBufferUnit, globalLight->getSchemaBuffer());
|
|
}
|
|
/*
|
|
void DeferredLightingEffect::loadLightProgram(const char* fragSource, bool limited, ProgramObject& program, LightLocations& locations) {
|
|
program.addShaderFromSourceCode(QGLShader::Vertex, (limited ? deferred_light_limited_vert : deferred_light_vert));
|
|
program.addShaderFromSourceCode(QGLShader::Fragment, fragSource);
|
|
program.link();
|
|
|
|
program.bind();
|
|
program.setUniformValue("diffuseMap", 0);
|
|
program.setUniformValue("normalMap", 1);
|
|
program.setUniformValue("specularMap", 2);
|
|
program.setUniformValue("depthMap", 3);
|
|
program.setUniformValue("shadowMap", 4);
|
|
program.setUniformValue("skyboxMap", 5);
|
|
locations.shadowDistances = program.uniformLocation("shadowDistances");
|
|
locations.shadowScale = program.uniformLocation("shadowScale");
|
|
locations.nearLocation = program.uniformLocation("near");
|
|
locations.depthScale = program.uniformLocation("depthScale");
|
|
locations.depthTexCoordOffset = program.uniformLocation("depthTexCoordOffset");
|
|
locations.depthTexCoordScale = program.uniformLocation("depthTexCoordScale");
|
|
locations.radius = program.uniformLocation("radius");
|
|
locations.ambientSphere = program.uniformLocation("ambientSphere.L00");
|
|
locations.invViewMat = program.uniformLocation("invViewMat");
|
|
|
|
GLint loc = -1;
|
|
|
|
#if (GPU_FEATURE_PROFILE == GPU_CORE)
|
|
const GLint LIGHT_GPU_SLOT = 3;
|
|
loc = glGetUniformBlockIndex(program.programId(), "lightBuffer");
|
|
if (loc >= 0) {
|
|
glUniformBlockBinding(program.programId(), loc, LIGHT_GPU_SLOT);
|
|
locations.lightBufferUnit = LIGHT_GPU_SLOT;
|
|
} else {
|
|
locations.lightBufferUnit = -1;
|
|
}
|
|
#else
|
|
loc = program.uniformLocation("lightBuffer");
|
|
if (loc >= 0) {
|
|
locations.lightBufferUnit = loc;
|
|
} else {
|
|
locations.lightBufferUnit = -1;
|
|
}
|
|
#endif
|
|
|
|
#if (GPU_FEATURE_PROFILE == GPU_CORE)
|
|
const GLint ATMOSPHERE_GPU_SLOT = 4;
|
|
loc = glGetUniformBlockIndex(program.programId(), "atmosphereBufferUnit");
|
|
if (loc >= 0) {
|
|
glUniformBlockBinding(program.programId(), loc, ATMOSPHERE_GPU_SLOT);
|
|
locations.atmosphereBufferUnit = ATMOSPHERE_GPU_SLOT;
|
|
} else {
|
|
locations.atmosphereBufferUnit = -1;
|
|
}
|
|
#else
|
|
loc = program.uniformLocation("atmosphereBufferUnit");
|
|
if (loc >= 0) {
|
|
locations.atmosphereBufferUnit = loc;
|
|
} else {
|
|
locations.atmosphereBufferUnit = -1;
|
|
}
|
|
#endif
|
|
|
|
program.release();
|
|
}
|
|
*/
|
|
|
|
|
|
void DeferredLightingEffect::loadLightProgram(const char* fragSource, bool lightVolume, gpu::PipelinePointer& pipeline, LightLocations& locations) {
|
|
auto VS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string((lightVolume ? deferred_light_limited_vert : deferred_light_vert))));
|
|
auto PS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(fragSource)));
|
|
|
|
gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(VS, PS));
|
|
|
|
gpu::Shader::BindingSet slotBindings;
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("diffuseMap"), 0));
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("normalMap"), 1));
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("specularMap"), 2));
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("depthMap"), 3));
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("shadowMap"), 4));
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), 5));
|
|
const GLint LIGHT_GPU_SLOT = 3;
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), LIGHT_GPU_SLOT));
|
|
const GLint ATMOSPHERE_GPU_SLOT = 4;
|
|
slotBindings.insert(gpu::Shader::Binding(std::string("atmosphereBufferUnit"), ATMOSPHERE_GPU_SLOT));
|
|
|
|
gpu::Shader::makeProgram(*program, slotBindings);
|
|
|
|
locations.shadowDistances = program->getUniforms().findLocation("shadowDistances");
|
|
locations.shadowScale = program->getUniforms().findLocation("shadowScale");
|
|
locations.nearLocation = program->getUniforms().findLocation("near");
|
|
locations.depthScale = program->getUniforms().findLocation("depthScale");
|
|
locations.depthTexCoordOffset = program->getUniforms().findLocation("depthTexCoordOffset");
|
|
locations.depthTexCoordScale = program->getUniforms().findLocation("depthTexCoordScale");
|
|
locations.radius = program->getUniforms().findLocation("radius");
|
|
locations.ambientSphere = program->getUniforms().findLocation("ambientSphere.L00");
|
|
locations.invViewMat = program->getUniforms().findLocation("invViewMat");
|
|
locations.texcoordMat = program->getUniforms().findLocation("texcoordMat");
|
|
|
|
#if (GPU_FEATURE_PROFILE == GPU_CORE)
|
|
locations.lightBufferUnit = program->getBuffers().findLocation("lightBuffer");
|
|
locations.atmosphereBufferUnit = program->getBuffers().findLocation("atmosphereBufferUnit");
|
|
#else
|
|
locations.lightBufferUnit = program->getUniforms().findLocation("lightBuffer");
|
|
locations.atmosphereBufferUnit = program->getUniforms().findLocation("atmosphereBufferUnit");
|
|
#endif
|
|
|
|
gpu::StatePointer state = gpu::StatePointer(new gpu::State());
|
|
if (lightVolume) {
|
|
state->setCullMode(gpu::State::CULL_BACK);
|
|
|
|
// additive blending
|
|
state->setBlendFunction(true, gpu::State::ONE, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
|
|
} else {
|
|
state->setCullMode(gpu::State::CULL_BACK);
|
|
}
|
|
pipeline.reset(gpu::Pipeline::create(program, state));
|
|
|
|
}
|
|
|
|
void DeferredLightingEffect::setAmbientLightMode(int preset) {
|
|
if ((preset >= 0) && (preset < gpu::SphericalHarmonics::NUM_PRESET)) {
|
|
_ambientLightMode = preset;
|
|
auto light = _allocatedLights.front();
|
|
light->setAmbientSpherePreset(gpu::SphericalHarmonics::Preset(preset % gpu::SphericalHarmonics::NUM_PRESET));
|
|
} else {
|
|
// force to preset 0
|
|
setAmbientLightMode(0);
|
|
}
|
|
}
|
|
|
|
void DeferredLightingEffect::setGlobalLight(const glm::vec3& direction, const glm::vec3& diffuse, float intensity, float ambientIntensity) {
|
|
auto light = _allocatedLights.front();
|
|
light->setDirection(direction);
|
|
light->setColor(diffuse);
|
|
light->setIntensity(intensity);
|
|
light->setAmbientIntensity(ambientIntensity);
|
|
}
|
|
|
|
void DeferredLightingEffect::setGlobalSkybox(const model::SkyboxPointer& skybox) {
|
|
_skybox = skybox;
|
|
}
|
|
|
|
model::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
|
|
if (!_spotLightMesh) {
|
|
_spotLightMesh.reset(new model::Mesh());
|
|
|
|
int slices = 32;
|
|
int stacks = 1;
|
|
int vertices = (stacks + 2) * slices;
|
|
int baseTriangles = slices - 2;
|
|
int indices = 6 * slices * stacks + 3 * baseTriangles;
|
|
|
|
GLfloat* vertexData = new GLfloat[vertices * 3];
|
|
GLfloat* vertex = vertexData;
|
|
// cap
|
|
for (int i = 0; i < slices; i++) {
|
|
float theta = TWO_PI * i / slices;
|
|
|
|
//normals
|
|
/* *(vertex++) = 0.0f;
|
|
*(vertex++) = 0.0f;
|
|
*(vertex++) = -1.0f;
|
|
*/
|
|
// vertices
|
|
*(vertex++) = cosf(theta);
|
|
*(vertex++) = sinf(theta);
|
|
*(vertex++) = 0.0f;
|
|
}
|
|
// body
|
|
for (int i = 0; i <= stacks; i++) {
|
|
float z = (float)i / stacks;
|
|
float radius = 1.0f - z;
|
|
|
|
for (int j = 0; j < slices; j++) {
|
|
float theta = TWO_PI * j / slices;
|
|
|
|
//normals
|
|
/* *(vertex++) = cosf(theta) / SQUARE_ROOT_OF_2;
|
|
*(vertex++) = sinf(theta) / SQUARE_ROOT_OF_2;
|
|
*(vertex++) = 1.0f / SQUARE_ROOT_OF_2;
|
|
*/
|
|
// vertices
|
|
*(vertex++) = radius * cosf(theta);
|
|
*(vertex++) = radius * sinf(theta);
|
|
*(vertex++) = z;
|
|
}
|
|
}
|
|
|
|
_spotLightMesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(sizeof(GLfloat) * vertices, (gpu::Byte*) vertexData), gpu::Element::VEC3F_XYZ));
|
|
delete[] vertexData;
|
|
|
|
|
|
GLushort* indexData = new GLushort[indices];
|
|
GLushort* index = indexData;
|
|
for (int i = 0; i < baseTriangles; i++) {
|
|
*(index++) = 0;
|
|
*(index++) = i + 2;
|
|
*(index++) = i + 1;
|
|
}
|
|
for (int i = 1; i <= stacks; i++) {
|
|
GLushort bottom = i * slices;
|
|
GLushort top = bottom + slices;
|
|
for (int j = 0; j < slices; j++) {
|
|
int next = (j + 1) % slices;
|
|
|
|
*(index++) = bottom + j;
|
|
*(index++) = top + next;
|
|
*(index++) = top + j;
|
|
|
|
*(index++) = bottom + j;
|
|
*(index++) = bottom + next;
|
|
*(index++) = top + next;
|
|
}
|
|
}
|
|
|
|
_spotLightMesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(sizeof(GLushort) * indices, (gpu::Byte*) indexData), gpu::Element::INDEX_UINT16));
|
|
delete[] indexData;
|
|
|
|
model::Mesh::Part part(0, vertices - 1, 0, model::Mesh::TRIANGLES);
|
|
|
|
_spotLightMesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(sizeof(part), (gpu::Byte*) &part), gpu::Element::PART_DRAWCALL));
|
|
|
|
_spotLightMesh->makeBufferStream();
|
|
}
|
|
return _spotLightMesh;
|
|
}
|
|
|