mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-04-07 10:02:24 +02:00
Merge branch 'ao' of http://github.com/Zvork/hifi into ao
This commit is contained in:
Olivier Prat
commit
45e0f65972
43 changed files with 1940 additions and 834 deletions
|
|
@ -177,6 +177,15 @@ void GLBackend::shutdown() {
|
|||
killShaderBinaryCache();
|
||||
}
|
||||
|
||||
void GLBackend::do_draw(const Batch& batch, size_t paramOffset) {
|
||||
Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
|
||||
GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];
|
||||
uint32 numVertices = batch._params[paramOffset + 1]._uint;
|
||||
uint32 startVertex = batch._params[paramOffset + 0]._uint;
|
||||
|
||||
draw(mode, numVertices, startVertex);
|
||||
}
|
||||
|
||||
void GLBackend::renderPassTransfer(const Batch& batch) {
|
||||
const size_t numCommands = batch.getCommands().size();
|
||||
const Batch::Commands::value_type* command = batch.getCommands().data();
|
||||
|
|
|
|||
|
|
@ -275,7 +275,7 @@ public:
|
|||
size_t getMaxNumResourceTextureTables() const { return MAX_NUM_RESOURCE_TABLE_TEXTURES; }
|
||||
|
||||
// Draw Stage
|
||||
virtual void do_draw(const Batch& batch, size_t paramOffset) = 0;
|
||||
virtual void do_draw(const Batch& batch, size_t paramOffset);
|
||||
virtual void do_drawIndexed(const Batch& batch, size_t paramOffset) = 0;
|
||||
virtual void do_drawInstanced(const Batch& batch, size_t paramOffset) = 0;
|
||||
virtual void do_drawIndexedInstanced(const Batch& batch, size_t paramOffset) = 0;
|
||||
|
|
|
|||
|
|
@ -329,6 +329,8 @@ GLenum GLTexelFormat::evalGLTexelFormatInternal(const gpu::Element& dstFormat) {
|
|||
result = GL_RGBA8_SNORM;
|
||||
break;
|
||||
case gpu::NINT2_10_10_10:
|
||||
result = GL_RGB10_A2;
|
||||
break;
|
||||
case gpu::NUINT32:
|
||||
case gpu::NINT32:
|
||||
case gpu::COMPRESSED:
|
||||
|
|
@ -729,9 +731,9 @@ GLTexelFormat GLTexelFormat::evalGLTexelFormat(const Element& dstFormat, const E
|
|||
texel.internalFormat = GL_DEPTH_COMPONENT24;
|
||||
break;
|
||||
}
|
||||
case gpu::NINT2_10_10_10:
|
||||
case gpu::COMPRESSED:
|
||||
case gpu::NUINT2:
|
||||
case gpu::NINT2_10_10_10:
|
||||
case gpu::NUM_TYPES: { // quiet compiler
|
||||
Q_UNREACHABLE();
|
||||
}
|
||||
|
|
@ -893,9 +895,12 @@ GLTexelFormat GLTexelFormat::evalGLTexelFormat(const Element& dstFormat, const E
|
|||
texel.format = GL_RGBA;
|
||||
texel.internalFormat = GL_RGBA2;
|
||||
break;
|
||||
case gpu::NINT2_10_10_10:
|
||||
texel.format = GL_RGBA;
|
||||
texel.internalFormat = GL_RGB10_A2;
|
||||
break;
|
||||
case gpu::NUINT32:
|
||||
case gpu::NINT32:
|
||||
case gpu::NINT2_10_10_10:
|
||||
case gpu::COMPRESSED:
|
||||
case gpu::NUM_TYPES: // quiet compiler
|
||||
Q_UNREACHABLE();
|
||||
|
|
|
|||
|
|
@ -43,34 +43,6 @@ void GL41Backend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
|
|||
(void)CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
void GL41Backend::do_draw(const Batch& batch, size_t paramOffset) {
|
||||
Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
|
||||
GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];
|
||||
uint32 numVertices = batch._params[paramOffset + 1]._uint;
|
||||
uint32 startVertex = batch._params[paramOffset + 0]._uint;
|
||||
|
||||
if (isStereo()) {
|
||||
#ifdef GPU_STEREO_DRAWCALL_INSTANCED
|
||||
glDrawArraysInstanced(mode, startVertex, numVertices, 2);
|
||||
#else
|
||||
setupStereoSide(0);
|
||||
glDrawArrays(mode, startVertex, numVertices);
|
||||
setupStereoSide(1);
|
||||
glDrawArrays(mode, startVertex, numVertices);
|
||||
#endif
|
||||
_stats._DSNumTriangles += 2 * numVertices / 3;
|
||||
_stats._DSNumDrawcalls += 2;
|
||||
|
||||
} else {
|
||||
glDrawArrays(mode, startVertex, numVertices);
|
||||
_stats._DSNumTriangles += numVertices / 3;
|
||||
_stats._DSNumDrawcalls++;
|
||||
}
|
||||
_stats._DSNumAPIDrawcalls++;
|
||||
|
||||
(void) CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
void GL41Backend::do_drawIndexed(const Batch& batch, size_t paramOffset) {
|
||||
Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
|
||||
GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];
|
||||
|
|
|
|||
|
|
@ -147,7 +147,6 @@ protected:
|
|||
GLQuery* syncGPUObject(const Query& query) override;
|
||||
|
||||
// Draw Stage
|
||||
void do_draw(const Batch& batch, size_t paramOffset) override;
|
||||
void do_drawIndexed(const Batch& batch, size_t paramOffset) override;
|
||||
void do_drawInstanced(const Batch& batch, size_t paramOffset) override;
|
||||
void do_drawIndexedInstanced(const Batch& batch, size_t paramOffset) override;
|
||||
|
|
|
|||
|
|
@ -66,35 +66,6 @@ void GL45Backend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
|
|||
(void)CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
void GL45Backend::do_draw(const Batch& batch, size_t paramOffset) {
|
||||
Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
|
||||
GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];
|
||||
uint32 numVertices = batch._params[paramOffset + 1]._uint;
|
||||
uint32 startVertex = batch._params[paramOffset + 0]._uint;
|
||||
|
||||
if (isStereo()) {
|
||||
#ifdef GPU_STEREO_DRAWCALL_INSTANCED
|
||||
glDrawArraysInstanced(mode, startVertex, numVertices, 2);
|
||||
#else
|
||||
setupStereoSide(0);
|
||||
glDrawArrays(mode, startVertex, numVertices);
|
||||
setupStereoSide(1);
|
||||
glDrawArrays(mode, startVertex, numVertices);
|
||||
#endif
|
||||
|
||||
_stats._DSNumTriangles += 2 * numVertices / 3;
|
||||
_stats._DSNumDrawcalls += 2;
|
||||
|
||||
} else {
|
||||
glDrawArrays(mode, startVertex, numVertices);
|
||||
_stats._DSNumTriangles += numVertices / 3;
|
||||
_stats._DSNumDrawcalls++;
|
||||
}
|
||||
_stats._DSNumAPIDrawcalls++;
|
||||
|
||||
(void) CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
void GL45Backend::do_drawIndexed(const Batch& batch, size_t paramOffset) {
|
||||
Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
|
||||
GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];
|
||||
|
|
|
|||
|
|
@ -248,7 +248,6 @@ protected:
|
|||
GLQuery* syncGPUObject(const Query& query) override;
|
||||
|
||||
// Draw Stage
|
||||
void do_draw(const Batch& batch, size_t paramOffset) override;
|
||||
void do_drawIndexed(const Batch& batch, size_t paramOffset) override;
|
||||
void do_drawInstanced(const Batch& batch, size_t paramOffset) override;
|
||||
void do_drawIndexedInstanced(const Batch& batch, size_t paramOffset) override;
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@
|
|||
#include <string.h>
|
||||
|
||||
#include <QDebug>
|
||||
#include "ShaderConstants.h"
|
||||
|
||||
#include "GPULogging.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
|
||||
#include "Frame.h"
|
||||
#include "GPULogging.h"
|
||||
#include <shaders/Shaders.h>
|
||||
|
||||
using namespace gpu;
|
||||
|
||||
|
|
@ -331,11 +332,20 @@ Size Context::getTextureResourcePopulatedGPUMemSize() {
|
|||
return Backend::textureResourcePopulatedGPUMemSize.getValue();
|
||||
}
|
||||
|
||||
PipelinePointer Context::createMipGenerationPipeline(const ShaderPointer& ps) {
|
||||
auto vs = gpu::Shader::createVertex(shader::gpu::vertex::DrawViewportQuadTransformTexcoord);
|
||||
static gpu::StatePointer state(new gpu::State());
|
||||
|
||||
gpu::ShaderPointer program = gpu::Shader::createProgram(vs, ps);
|
||||
|
||||
// Good to go add the brand new pipeline
|
||||
return gpu::Pipeline::create(program, state);
|
||||
}
|
||||
|
||||
Size Context::getTextureResourceIdealGPUMemSize() {
|
||||
return Backend::textureResourceIdealGPUMemSize.getValue();
|
||||
}
|
||||
|
||||
|
||||
BatchPointer Context::acquireBatch(const char* name) {
|
||||
Batch* rawBatch = nullptr;
|
||||
{
|
||||
|
|
|
|||
|
|
@ -218,6 +218,8 @@ public:
|
|||
// Same as above but grabbed at every end of a frame
|
||||
void getFrameStats(ContextStats& stats) const;
|
||||
|
||||
static PipelinePointer createMipGenerationPipeline(const ShaderPointer& pixelShader);
|
||||
|
||||
double getFrameTimerGPUAverage() const;
|
||||
double getFrameTimerBatchAverage() const;
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -21,6 +21,8 @@
|
|||
#include "DeferredFramebuffer.h"
|
||||
#include "SurfaceGeometryPass.h"
|
||||
|
||||
#include "ssao_shared.h"
|
||||
|
||||
class AmbientOcclusionFramebuffer {
|
||||
public:
|
||||
AmbientOcclusionFramebuffer();
|
||||
|
|
@ -30,13 +32,23 @@ public:
|
|||
|
||||
gpu::FramebufferPointer getOcclusionBlurredFramebuffer();
|
||||
gpu::TexturePointer getOcclusionBlurredTexture();
|
||||
|
||||
|
||||
gpu::FramebufferPointer getNormalFramebuffer();
|
||||
gpu::TexturePointer getNormalTexture();
|
||||
|
||||
#if SSAO_USE_QUAD_SPLIT
|
||||
gpu::FramebufferPointer getOcclusionSplitFramebuffer(int index);
|
||||
gpu::TexturePointer getOcclusionSplitTexture();
|
||||
#endif
|
||||
|
||||
// Update the source framebuffer size which will drive the allocation of all the other resources.
|
||||
void updateLinearDepth(const gpu::TexturePointer& linearDepthBuffer);
|
||||
bool update(const gpu::TexturePointer& linearDepthBuffer, int resolutionLevel, int depthResolutionLevel, bool isStereo);
|
||||
gpu::TexturePointer getLinearDepthTexture();
|
||||
const glm::ivec2& getSourceFrameSize() const { return _frameSize; }
|
||||
|
||||
bool isStereo() const { return _isStereo; }
|
||||
|
||||
protected:
|
||||
|
||||
void clear();
|
||||
void allocate();
|
||||
|
||||
|
|
@ -44,12 +56,22 @@ protected:
|
|||
|
||||
gpu::FramebufferPointer _occlusionFramebuffer;
|
||||
gpu::TexturePointer _occlusionTexture;
|
||||
|
||||
|
||||
gpu::FramebufferPointer _occlusionBlurredFramebuffer;
|
||||
gpu::TexturePointer _occlusionBlurredTexture;
|
||||
|
||||
|
||||
|
||||
gpu::FramebufferPointer _normalFramebuffer;
|
||||
gpu::TexturePointer _normalTexture;
|
||||
|
||||
#if SSAO_USE_QUAD_SPLIT
|
||||
gpu::FramebufferPointer _occlusionSplitFramebuffers[SSAO_SPLIT_COUNT*SSAO_SPLIT_COUNT];
|
||||
gpu::TexturePointer _occlusionSplitTexture;
|
||||
#endif
|
||||
|
||||
glm::ivec2 _frameSize;
|
||||
int _resolutionLevel{ 0 };
|
||||
int _depthResolutionLevel{ 0 };
|
||||
bool _isStereo{ false };
|
||||
};
|
||||
|
||||
using AmbientOcclusionFramebufferPointer = std::shared_ptr<AmbientOcclusionFramebuffer>;
|
||||
|
|
@ -57,53 +79,78 @@ using AmbientOcclusionFramebufferPointer = std::shared_ptr<AmbientOcclusionFrame
|
|||
class AmbientOcclusionEffectConfig : public render::GPUJobConfig::Persistent {
|
||||
Q_OBJECT
|
||||
Q_PROPERTY(bool enabled MEMBER enabled NOTIFY dirty)
|
||||
Q_PROPERTY(bool horizonBased MEMBER horizonBased NOTIFY dirty)
|
||||
Q_PROPERTY(bool ditheringEnabled MEMBER ditheringEnabled NOTIFY dirty)
|
||||
Q_PROPERTY(bool borderingEnabled MEMBER borderingEnabled NOTIFY dirty)
|
||||
Q_PROPERTY(bool fetchMipsEnabled MEMBER fetchMipsEnabled NOTIFY dirty)
|
||||
Q_PROPERTY(float radius MEMBER radius WRITE setRadius)
|
||||
Q_PROPERTY(float obscuranceLevel MEMBER obscuranceLevel WRITE setObscuranceLevel)
|
||||
Q_PROPERTY(float falloffBias MEMBER falloffBias WRITE setFalloffBias)
|
||||
Q_PROPERTY(float edgeSharpness MEMBER edgeSharpness WRITE setEdgeSharpness)
|
||||
Q_PROPERTY(float blurDeviation MEMBER blurDeviation WRITE setBlurDeviation)
|
||||
Q_PROPERTY(float numSpiralTurns MEMBER numSpiralTurns WRITE setNumSpiralTurns)
|
||||
Q_PROPERTY(int numSamples MEMBER numSamples WRITE setNumSamples)
|
||||
Q_PROPERTY(bool jitterEnabled MEMBER jitterEnabled NOTIFY dirty)
|
||||
|
||||
Q_PROPERTY(int resolutionLevel MEMBER resolutionLevel WRITE setResolutionLevel)
|
||||
Q_PROPERTY(float edgeSharpness MEMBER edgeSharpness WRITE setEdgeSharpness)
|
||||
Q_PROPERTY(int blurRadius MEMBER blurRadius WRITE setBlurRadius)
|
||||
|
||||
// SSAO
|
||||
Q_PROPERTY(float ssaoRadius MEMBER ssaoRadius WRITE setSSAORadius)
|
||||
Q_PROPERTY(float ssaoObscuranceLevel MEMBER ssaoObscuranceLevel WRITE setSSAOObscuranceLevel)
|
||||
Q_PROPERTY(float ssaoFalloffAngle MEMBER ssaoFalloffAngle WRITE setSSAOFalloffAngle)
|
||||
Q_PROPERTY(float ssaoNumSpiralTurns MEMBER ssaoNumSpiralTurns WRITE setSSAONumSpiralTurns)
|
||||
Q_PROPERTY(int ssaoNumSamples MEMBER ssaoNumSamples WRITE setSSAONumSamples)
|
||||
|
||||
// HBAO
|
||||
Q_PROPERTY(float hbaoRadius MEMBER hbaoRadius WRITE setHBAORadius)
|
||||
Q_PROPERTY(float hbaoObscuranceLevel MEMBER hbaoObscuranceLevel WRITE setHBAOObscuranceLevel)
|
||||
Q_PROPERTY(float hbaoFalloffAngle MEMBER hbaoFalloffAngle WRITE setHBAOFalloffAngle)
|
||||
Q_PROPERTY(int hbaoNumSamples MEMBER hbaoNumSamples WRITE setHBAONumSamples)
|
||||
|
||||
public:
|
||||
AmbientOcclusionEffectConfig() : render::GPUJobConfig::Persistent(QStringList() << "Render" << "Engine" << "Ambient Occlusion", false) {}
|
||||
AmbientOcclusionEffectConfig();
|
||||
|
||||
const int MAX_RESOLUTION_LEVEL = 4;
|
||||
const int MAX_BLUR_RADIUS = 6;
|
||||
const int MAX_BLUR_RADIUS = 15;
|
||||
|
||||
void setRadius(float newRadius) { radius = std::max(0.01f, newRadius); emit dirty(); }
|
||||
void setObscuranceLevel(float level) { obscuranceLevel = std::max(0.01f, level); emit dirty(); }
|
||||
void setFalloffBias(float bias) { falloffBias = std::max(0.0f, std::min(bias, 0.2f)); emit dirty(); }
|
||||
void setEdgeSharpness(float sharpness) { edgeSharpness = std::max(0.0f, (float)sharpness); emit dirty(); }
|
||||
void setBlurDeviation(float deviation) { blurDeviation = std::max(0.0f, deviation); emit dirty(); }
|
||||
void setNumSpiralTurns(float turns) { numSpiralTurns = std::max(0.0f, (float)turns); emit dirty(); }
|
||||
void setNumSamples(int samples) { numSamples = std::max(1.0f, (float)samples); emit dirty(); }
|
||||
void setResolutionLevel(int level) { resolutionLevel = std::max(0, std::min(level, MAX_RESOLUTION_LEVEL)); emit dirty(); }
|
||||
void setBlurRadius(int radius) { blurRadius = std::max(0, std::min(MAX_BLUR_RADIUS, radius)); emit dirty(); }
|
||||
void setEdgeSharpness(float sharpness);
|
||||
void setResolutionLevel(int level);
|
||||
void setBlurRadius(int radius);
|
||||
|
||||
float radius{ 0.5f };
|
||||
float perspectiveScale{ 1.0f };
|
||||
float obscuranceLevel{ 0.5f }; // intensify or dim down the obscurance effect
|
||||
float falloffBias{ 0.01f };
|
||||
float edgeSharpness{ 1.0f };
|
||||
float blurDeviation{ 2.5f };
|
||||
float numSpiralTurns{ 7.0f }; // defining an angle span to distribute the samples ray directions
|
||||
int numSamples{ 16 };
|
||||
int resolutionLevel{ 1 };
|
||||
int blurRadius{ 4 }; // 0 means no blurring
|
||||
bool ditheringEnabled{ true }; // randomize the distribution of taps per pixel, should always be true
|
||||
bool borderingEnabled{ true }; // avoid evaluating information from non existing pixels out of the frame, should always be true
|
||||
bool fetchMipsEnabled{ true }; // fetch taps in sub mips to otpimize cache, should always be true
|
||||
void setSSAORadius(float newRadius);
|
||||
void setSSAOObscuranceLevel(float level);
|
||||
void setSSAOFalloffAngle(float bias);
|
||||
void setSSAONumSpiralTurns(float turns);
|
||||
void setSSAONumSamples(int samples);
|
||||
|
||||
void setHBAORadius(float newRadius);
|
||||
void setHBAOObscuranceLevel(float level);
|
||||
void setHBAOFalloffAngle(float bias);
|
||||
void setHBAONumSamples(int samples);
|
||||
|
||||
float perspectiveScale;
|
||||
float edgeSharpness;
|
||||
int blurRadius; // 0 means no blurring
|
||||
int resolutionLevel;
|
||||
|
||||
float ssaoRadius;
|
||||
float ssaoObscuranceLevel; // intensify or dim down the obscurance effect
|
||||
float ssaoFalloffAngle;
|
||||
float ssaoNumSpiralTurns; // defining an angle span to distribute the samples ray directions
|
||||
int ssaoNumSamples;
|
||||
|
||||
float hbaoRadius;
|
||||
float hbaoObscuranceLevel; // intensify or dim down the obscurance effect
|
||||
float hbaoFalloffAngle;
|
||||
int hbaoNumSamples;
|
||||
|
||||
bool horizonBased; // Use horizon based AO
|
||||
bool ditheringEnabled; // randomize the distribution of taps per pixel, should always be true
|
||||
bool borderingEnabled; // avoid evaluating information from non existing pixels out of the frame, should always be true
|
||||
bool fetchMipsEnabled; // fetch taps in sub mips to otpimize cache, should always be true
|
||||
bool jitterEnabled; // Add small jittering to AO samples at each frame
|
||||
|
||||
signals:
|
||||
void dirty();
|
||||
};
|
||||
|
||||
#define SSAO_RANDOM_SAMPLE_COUNT 16
|
||||
|
||||
class AmbientOcclusionEffect {
|
||||
public:
|
||||
using Inputs = render::VaryingSet3<DeferredFrameTransformPointer, DeferredFramebufferPointer, LinearDepthFramebufferPointer>;
|
||||
|
|
@ -115,59 +162,75 @@ public:
|
|||
|
||||
void configure(const Config& config);
|
||||
void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
|
||||
|
||||
|
||||
// Class describing the uniform buffer with all the parameters common to the AO shaders
|
||||
class Parameters {
|
||||
class AOParameters : public AmbientOcclusionParams {
|
||||
public:
|
||||
// Resolution info
|
||||
glm::vec4 resolutionInfo { -1.0f, 0.0f, 1.0f, 0.0f };
|
||||
// radius info is { R, R^2, 1 / R^6, ObscuranceScale}
|
||||
glm::vec4 radiusInfo{ 0.5f, 0.5f * 0.5f, 1.0f / (0.25f * 0.25f * 0.25f), 1.0f };
|
||||
// Dithering info
|
||||
glm::vec4 ditheringInfo { 0.0f, 0.0f, 0.01f, 1.0f };
|
||||
// Sampling info
|
||||
glm::vec4 sampleInfo { 11.0f, 1.0f/11.0f, 7.0f, 1.0f };
|
||||
// Blurring info
|
||||
glm::vec4 blurInfo { 1.0f, 3.0f, 2.0f, 0.0f };
|
||||
// gaussian distribution coefficients first is the sampling radius (max is 6)
|
||||
const static int GAUSSIAN_COEFS_LENGTH = 8;
|
||||
float _gaussianCoefs[GAUSSIAN_COEFS_LENGTH];
|
||||
|
||||
Parameters() {}
|
||||
|
||||
int getResolutionLevel() const { return resolutionInfo.x; }
|
||||
float getRadius() const { return radiusInfo.x; }
|
||||
float getPerspectiveScale() const { return resolutionInfo.z; }
|
||||
float getObscuranceLevel() const { return radiusInfo.w; }
|
||||
float getFalloffBias() const { return (float)ditheringInfo.z; }
|
||||
float getEdgeSharpness() const { return (float)blurInfo.x; }
|
||||
float getBlurDeviation() const { return blurInfo.z; }
|
||||
AOParameters();
|
||||
|
||||
int getResolutionLevel() const { return _resolutionInfo.x; }
|
||||
float getRadius() const { return _radiusInfo.x; }
|
||||
float getPerspectiveScale() const { return _resolutionInfo.z; }
|
||||
float getObscuranceLevel() const { return _radiusInfo.w; }
|
||||
float getFalloffAngle() const { return (float)_falloffInfo.x; }
|
||||
|
||||
float getNumSpiralTurns() const { return sampleInfo.z; }
|
||||
int getNumSamples() const { return (int)sampleInfo.x; }
|
||||
bool isFetchMipsEnabled() const { return sampleInfo.w; }
|
||||
float getNumSpiralTurns() const { return _sampleInfo.z; }
|
||||
int getNumSamples() const { return (int)_sampleInfo.x; }
|
||||
bool isFetchMipsEnabled() const { return _sampleInfo.w; }
|
||||
|
||||
bool isDitheringEnabled() const { return _ditheringInfo.x != 0.0f; }
|
||||
bool isBorderingEnabled() const { return _ditheringInfo.w != 0.0f; }
|
||||
bool isHorizonBased() const { return _resolutionInfo.y != 0.0f; }
|
||||
|
||||
int getBlurRadius() const { return (int)blurInfo.y; }
|
||||
bool isDitheringEnabled() const { return ditheringInfo.x; }
|
||||
bool isBorderingEnabled() const { return ditheringInfo.w; }
|
||||
};
|
||||
using ParametersBuffer = gpu::StructBuffer<Parameters>;
|
||||
using AOParametersBuffer = gpu::StructBuffer<AOParameters>;
|
||||
|
||||
private:
|
||||
void updateGaussianDistribution();
|
||||
|
||||
// Class describing the uniform buffer with all the parameters common to the bilateral blur shaders
|
||||
class BlurParameters : public AmbientOcclusionBlurParams {
|
||||
public:
|
||||
|
||||
BlurParameters();
|
||||
|
||||
float getEdgeSharpness() const { return (float)_blurInfo.x; }
|
||||
int getBlurRadius() const { return (int)_blurInfo.w; }
|
||||
|
||||
};
|
||||
using BlurParametersBuffer = gpu::StructBuffer<BlurParameters>;
|
||||
|
||||
using FrameParametersBuffer = gpu::StructBuffer< AmbientOcclusionFrameParams>;
|
||||
|
||||
void updateBlurParameters();
|
||||
void updateFramebufferSizes();
|
||||
void updateRandomSamples();
|
||||
void updateJitterSamples();
|
||||
|
||||
int getDepthResolutionLevel() const;
|
||||
|
||||
ParametersBuffer _parametersBuffer;
|
||||
AOParametersBuffer _aoParametersBuffer;
|
||||
FrameParametersBuffer _aoFrameParametersBuffer[SSAO_SPLIT_COUNT*SSAO_SPLIT_COUNT];
|
||||
BlurParametersBuffer _vblurParametersBuffer;
|
||||
BlurParametersBuffer _hblurParametersBuffer;
|
||||
float _blurEdgeSharpness{ 0.0f };
|
||||
|
||||
const gpu::PipelinePointer& getOcclusionPipeline();
|
||||
const gpu::PipelinePointer& getHBlurPipeline(); // first
|
||||
const gpu::PipelinePointer& getVBlurPipeline(); // second
|
||||
static const gpu::PipelinePointer& getOcclusionPipeline();
|
||||
static const gpu::PipelinePointer& getBilateralBlurPipeline();
|
||||
static const gpu::PipelinePointer& getMipCreationPipeline();
|
||||
static const gpu::PipelinePointer& getGatherPipeline();
|
||||
static const gpu::PipelinePointer& getBuildNormalsPipeline();
|
||||
|
||||
gpu::PipelinePointer _occlusionPipeline;
|
||||
gpu::PipelinePointer _hBlurPipeline;
|
||||
gpu::PipelinePointer _vBlurPipeline;
|
||||
static gpu::PipelinePointer _occlusionPipeline;
|
||||
static gpu::PipelinePointer _bilateralBlurPipeline;
|
||||
static gpu::PipelinePointer _mipCreationPipeline;
|
||||
static gpu::PipelinePointer _gatherPipeline;
|
||||
static gpu::PipelinePointer _buildNormalsPipeline;
|
||||
|
||||
AmbientOcclusionFramebufferPointer _framebuffer;
|
||||
std::array<float, SSAO_RANDOM_SAMPLE_COUNT * SSAO_SPLIT_COUNT*SSAO_SPLIT_COUNT> _randomSamples;
|
||||
int _frameId{ 0 };
|
||||
bool _isJitterEnabled{ true };
|
||||
|
||||
gpu::RangeTimerPointer _gpuTimer;
|
||||
|
||||
|
|
@ -193,7 +256,7 @@ signals:
|
|||
|
||||
class DebugAmbientOcclusion {
|
||||
public:
|
||||
using Inputs = render::VaryingSet4<DeferredFrameTransformPointer, DeferredFramebufferPointer, LinearDepthFramebufferPointer, AmbientOcclusionEffect::ParametersBuffer>;
|
||||
using Inputs = render::VaryingSet4<DeferredFrameTransformPointer, DeferredFramebufferPointer, LinearDepthFramebufferPointer, AmbientOcclusionEffect::AOParametersBuffer>;
|
||||
using Config = DebugAmbientOcclusionConfig;
|
||||
using JobModel = render::Job::ModelI<DebugAmbientOcclusion, Inputs, Config>;
|
||||
|
||||
|
|
|
|||
|
|
@ -220,9 +220,7 @@ static const std::string DEFAULT_DEBUG_SCATTERING_SHADER{
|
|||
|
||||
static const std::string DEFAULT_AMBIENT_OCCLUSION_SHADER{
|
||||
"vec4 getFragmentColor() {"
|
||||
" return vec4(vec3(texture(obscuranceMap, uv).x), 1.0);"
|
||||
// When drawing color " return vec4(vec3(texture(debugTexture0, uv).xyz), 1.0);"
|
||||
// when drawing normal" return vec4(normalize(texture(debugTexture0, uv).xyz * 2.0 - vec3(1.0)), 1.0);"
|
||||
" return vec4(vec3(texture(debugTexture0, uv).x), 1.0);"
|
||||
" }"
|
||||
};
|
||||
static const std::string DEFAULT_AMBIENT_OCCLUSION_BLURRED_SHADER{
|
||||
|
|
@ -323,6 +321,8 @@ std::string DebugDeferredBuffer::getShaderSourceCode(Mode mode, const std::strin
|
|||
return DEFAULT_AMBIENT_OCCLUSION_SHADER;
|
||||
case AmbientOcclusionBlurredMode:
|
||||
return DEFAULT_AMBIENT_OCCLUSION_BLURRED_SHADER;
|
||||
case AmbientOcclusionNormalMode:
|
||||
return DEFAULT_HALF_NORMAL_SHADER;
|
||||
case VelocityMode:
|
||||
return DEFAULT_VELOCITY_SHADER;
|
||||
case CustomMode:
|
||||
|
|
@ -470,6 +470,8 @@ void DebugDeferredBuffer::run(const RenderContextPointer& renderContext, const I
|
|||
batch.setResourceTexture(Textures::DebugTexture0, ambientOcclusionFramebuffer->getOcclusionTexture());
|
||||
} else if (_mode == AmbientOcclusionBlurredMode) {
|
||||
batch.setResourceTexture(Textures::DebugTexture0, ambientOcclusionFramebuffer->getOcclusionBlurredTexture());
|
||||
} else if (_mode == AmbientOcclusionNormalMode) {
|
||||
batch.setResourceTexture(Textures::DebugTexture0, ambientOcclusionFramebuffer->getNormalTexture());
|
||||
}
|
||||
}
|
||||
const glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
|
|
|
|||
|
|
@ -91,6 +91,7 @@ protected:
|
|||
ScatteringDebugMode,
|
||||
AmbientOcclusionMode,
|
||||
AmbientOcclusionBlurredMode,
|
||||
AmbientOcclusionNormalMode,
|
||||
VelocityMode,
|
||||
CustomMode, // Needs to stay last
|
||||
|
||||
|
|
|
|||
|
|
@ -120,13 +120,22 @@ float getStereoSideHeight(int resolutionLevel) {
|
|||
return float(int(frameTransform._pixelInfo.w) >> resolutionLevel);
|
||||
}
|
||||
|
||||
vec2 getSideImageSize(int resolutionLevel) {
|
||||
return vec2(float(int(frameTransform._stereoInfo.y) >> resolutionLevel), float(int(frameTransform._pixelInfo.w) >> resolutionLevel));
|
||||
vec2 getStereoSideSize(int resolutionLevel) {
|
||||
return vec2(getStereoSideWidth(resolutionLevel), getStereoSideHeight(resolutionLevel));
|
||||
}
|
||||
|
||||
ivec4 getStereoSideInfoFromWidth(int xPos, int sideWidth) {
|
||||
return ivec4(xPos < sideWidth ? ivec2(0, 0) : ivec2(1, sideWidth), sideWidth, isStereo());
|
||||
}
|
||||
|
||||
ivec4 getStereoSideInfo(int xPos, int resolutionLevel) {
|
||||
int sideWidth = int(getStereoSideWidth(resolutionLevel));
|
||||
return ivec4(xPos < sideWidth ? ivec2(0, 0) : ivec2(1, sideWidth), sideWidth, isStereo());
|
||||
return getStereoSideInfoFromWidth(xPos, sideWidth);
|
||||
}
|
||||
|
||||
|
||||
int getStereoSide(ivec4 sideInfo) {
|
||||
return sideInfo.x;
|
||||
}
|
||||
|
||||
float evalZeyeFromZdb(float depth) {
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@
|
|||
#include "SurfaceGeometryPass.h"
|
||||
|
||||
#include <limits>
|
||||
#include <MathUtils.h>
|
||||
|
||||
#include <gpu/Context.h>
|
||||
#include <shaders/Shaders.h>
|
||||
|
|
@ -28,19 +29,27 @@ namespace ru {
|
|||
LinearDepthFramebuffer::LinearDepthFramebuffer() {
|
||||
}
|
||||
|
||||
void LinearDepthFramebuffer::updatePrimaryDepth(const gpu::TexturePointer& depthBuffer) {
|
||||
void LinearDepthFramebuffer::update(const gpu::TexturePointer& depthBuffer, const gpu::TexturePointer& normalTexture, bool isStereo) {
|
||||
//If the depth buffer or size changed, we need to delete our FBOs
|
||||
bool reset = false;
|
||||
if ((_primaryDepthTexture != depthBuffer)) {
|
||||
if (_primaryDepthTexture != depthBuffer || _normalTexture != normalTexture) {
|
||||
_primaryDepthTexture = depthBuffer;
|
||||
_normalTexture = normalTexture;
|
||||
reset = true;
|
||||
}
|
||||
if (_primaryDepthTexture) {
|
||||
auto newFrameSize = glm::ivec2(_primaryDepthTexture->getDimensions());
|
||||
if (_frameSize != newFrameSize) {
|
||||
if (_frameSize != newFrameSize || _isStereo != isStereo) {
|
||||
_frameSize = newFrameSize;
|
||||
_halfFrameSize = newFrameSize >> 1;
|
||||
|
||||
_halfFrameSize = _frameSize;
|
||||
if (isStereo) {
|
||||
_halfFrameSize.x >>= 1;
|
||||
}
|
||||
_halfFrameSize >>= 1;
|
||||
if (isStereo) {
|
||||
_halfFrameSize.x <<= 1;
|
||||
}
|
||||
_isStereo = isStereo;
|
||||
reset = true;
|
||||
}
|
||||
}
|
||||
|
|
@ -64,16 +73,22 @@ void LinearDepthFramebuffer::allocate() {
|
|||
auto height = _frameSize.y;
|
||||
|
||||
// For Linear Depth:
|
||||
_linearDepthTexture = gpu::Texture::createRenderBuffer(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::RED), width, height, gpu::Texture::SINGLE_MIP,
|
||||
gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT));
|
||||
const uint16_t LINEAR_DEPTH_MAX_MIP_LEVEL = 5;
|
||||
// Point sampling of the depth, as well as the clamp to edge, are needed for the AmbientOcclusionEffect with HBAO
|
||||
const auto depthSamplerFull = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_POINT, gpu::Sampler::WRAP_CLAMP);
|
||||
_linearDepthTexture = gpu::Texture::createRenderBuffer(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::RED), width, height, LINEAR_DEPTH_MAX_MIP_LEVEL,
|
||||
depthSamplerFull);
|
||||
_linearDepthFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create("linearDepth"));
|
||||
_linearDepthFramebuffer->setRenderBuffer(0, _linearDepthTexture);
|
||||
_linearDepthFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, _primaryDepthTexture->getTexelFormat());
|
||||
|
||||
// For Downsampling:
|
||||
const uint16_t HALF_LINEAR_DEPTH_MAX_MIP_LEVEL = 5;
|
||||
_halfLinearDepthTexture = gpu::Texture::createRenderBuffer(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::RED), _halfFrameSize.x, _halfFrameSize.y, HALF_LINEAR_DEPTH_MAX_MIP_LEVEL,
|
||||
gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT));
|
||||
// Point sampling of the depth, as well as the clamp to edge, are needed for the AmbientOcclusionEffect with HBAO
|
||||
const auto depthSamplerHalf = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_POINT, gpu::Sampler::WRAP_CLAMP);
|
||||
// The depth format here is half float as it increases performance in the AmbientOcclusion. But it might be needed elsewhere...
|
||||
_halfLinearDepthTexture = gpu::Texture::createRenderBuffer(gpu::Element(gpu::SCALAR, gpu::HALF, gpu::RED), _halfFrameSize.x, _halfFrameSize.y, HALF_LINEAR_DEPTH_MAX_MIP_LEVEL,
|
||||
depthSamplerHalf);
|
||||
|
||||
_halfNormalTexture = gpu::Texture::createRenderBuffer(gpu::Element::COLOR_RGBA_32, _halfFrameSize.x, _halfFrameSize.y, gpu::Texture::SINGLE_MIP,
|
||||
gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT));
|
||||
|
|
@ -97,6 +112,10 @@ gpu::TexturePointer LinearDepthFramebuffer::getLinearDepthTexture() {
|
|||
return _linearDepthTexture;
|
||||
}
|
||||
|
||||
gpu::TexturePointer LinearDepthFramebuffer::getNormalTexture() {
|
||||
return _normalTexture;
|
||||
}
|
||||
|
||||
gpu::FramebufferPointer LinearDepthFramebuffer::getDownsampleFramebuffer() {
|
||||
if (!_downsampleFramebuffer) {
|
||||
allocate();
|
||||
|
|
@ -141,11 +160,12 @@ void LinearDepthPass::run(const render::RenderContextPointer& renderContext, con
|
|||
if (!_linearDepthFramebuffer) {
|
||||
_linearDepthFramebuffer = std::make_shared<LinearDepthFramebuffer>();
|
||||
}
|
||||
_linearDepthFramebuffer->updatePrimaryDepth(deferredFramebuffer->getPrimaryDepthTexture());
|
||||
|
||||
auto depthBuffer = deferredFramebuffer->getPrimaryDepthTexture();
|
||||
auto normalTexture = deferredFramebuffer->getDeferredNormalTexture();
|
||||
|
||||
_linearDepthFramebuffer->update(depthBuffer, normalTexture, args->isStereo());
|
||||
|
||||
auto linearDepthFBO = _linearDepthFramebuffer->getLinearDepthFramebuffer();
|
||||
auto linearDepthTexture = _linearDepthFramebuffer->getLinearDepthTexture();
|
||||
|
||||
|
|
@ -167,32 +187,34 @@ void LinearDepthPass::run(const render::RenderContextPointer& renderContext, con
|
|||
float clearLinearDepth = args->getViewFrustum().getFarClip() * 2.0f;
|
||||
|
||||
gpu::doInBatch("LinearDepthPass::run", args->_context, [=](gpu::Batch& batch) {
|
||||
PROFILE_RANGE_BATCH(batch, "LinearDepthPass");
|
||||
_gpuTimer->begin(batch);
|
||||
|
||||
batch.enableStereo(false);
|
||||
|
||||
batch.setViewportTransform(depthViewport);
|
||||
batch.setProjectionTransform(glm::mat4());
|
||||
batch.resetViewTransform();
|
||||
batch.setModelTransform(gpu::Framebuffer::evalSubregionTexcoordTransform(_linearDepthFramebuffer->getDepthFrameSize(), depthViewport));
|
||||
|
||||
batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, frameTransform->getFrameTransformBuffer());
|
||||
|
||||
// LinearDepth
|
||||
batch.setViewportTransform(depthViewport);
|
||||
batch.setFramebuffer(linearDepthFBO);
|
||||
batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, glm::vec4(clearLinearDepth, 0.0f, 0.0f, 0.0f));
|
||||
batch.setPipeline(linearDepthPipeline);
|
||||
batch.setModelTransform(gpu::Framebuffer::evalSubregionTexcoordTransform(_linearDepthFramebuffer->getDepthFrameSize(), depthViewport));
|
||||
batch.setResourceTexture(ru::Texture::SurfaceGeometryDepth, depthBuffer);
|
||||
batch.draw(gpu::TRIANGLE_STRIP, 4);
|
||||
|
||||
// Downsample
|
||||
batch.setViewportTransform(halfViewport);
|
||||
|
||||
batch.setFramebuffer(downsampleFBO);
|
||||
batch.setResourceTexture(ru::Texture::SurfaceGeometryDepth, linearDepthTexture);
|
||||
batch.setResourceTexture(ru::Texture::SurfaceGeometryNormal, normalTexture);
|
||||
batch.setPipeline(downsamplePipeline);
|
||||
batch.setModelTransform(gpu::Framebuffer::evalSubregionTexcoordTransform(_linearDepthFramebuffer->getDepthFrameSize() >> 1, halfViewport));
|
||||
batch.draw(gpu::TRIANGLE_STRIP, 4);
|
||||
|
||||
|
||||
_gpuTimer->end(batch);
|
||||
});
|
||||
|
||||
|
|
@ -244,7 +266,7 @@ const gpu::PipelinePointer& LinearDepthPass::getDownsamplePipeline(const render:
|
|||
SurfaceGeometryFramebuffer::SurfaceGeometryFramebuffer() {
|
||||
}
|
||||
|
||||
void SurfaceGeometryFramebuffer::updateLinearDepth(const gpu::TexturePointer& linearDepthBuffer) {
|
||||
void SurfaceGeometryFramebuffer::update(const gpu::TexturePointer& linearDepthBuffer) {
|
||||
//If the depth buffer or size changed, we need to delete our FBOs
|
||||
bool reset = false;
|
||||
if ((_linearDepthTexture != linearDepthBuffer)) {
|
||||
|
|
@ -411,7 +433,7 @@ void SurfaceGeometryPass::run(const render::RenderContextPointer& renderContext,
|
|||
if (!_surfaceGeometryFramebuffer) {
|
||||
_surfaceGeometryFramebuffer = std::make_shared<SurfaceGeometryFramebuffer>();
|
||||
}
|
||||
_surfaceGeometryFramebuffer->updateLinearDepth(linearDepthTexture);
|
||||
_surfaceGeometryFramebuffer->update(linearDepthTexture);
|
||||
|
||||
auto curvatureFramebuffer = _surfaceGeometryFramebuffer->getCurvatureFramebuffer();
|
||||
auto curvatureTexture = _surfaceGeometryFramebuffer->getCurvatureTexture();
|
||||
|
|
|
|||
|
|
@ -28,17 +28,17 @@ public:
|
|||
|
||||
gpu::FramebufferPointer getLinearDepthFramebuffer();
|
||||
gpu::TexturePointer getLinearDepthTexture();
|
||||
gpu::TexturePointer getNormalTexture();
|
||||
|
||||
gpu::FramebufferPointer getDownsampleFramebuffer();
|
||||
gpu::TexturePointer getHalfLinearDepthTexture();
|
||||
gpu::TexturePointer getHalfNormalTexture();
|
||||
|
||||
// Update the depth buffer which will drive the allocation of all the other resources according to its size.
|
||||
void updatePrimaryDepth(const gpu::TexturePointer& depthBuffer);
|
||||
gpu::TexturePointer getPrimaryDepthTexture();
|
||||
void update(const gpu::TexturePointer& depthBuffer, const gpu::TexturePointer& normalTexture, bool isStereo);
|
||||
const glm::ivec2& getDepthFrameSize() const { return _frameSize; }
|
||||
|
||||
void setResolutionLevel(int level);
|
||||
void setResolutionLevel(int level) { _resolutionLevel = std::max(0, level); }
|
||||
int getResolutionLevel() const { return _resolutionLevel; }
|
||||
|
||||
protected:
|
||||
|
|
@ -49,6 +49,7 @@ protected:
|
|||
|
||||
gpu::FramebufferPointer _linearDepthFramebuffer;
|
||||
gpu::TexturePointer _linearDepthTexture;
|
||||
gpu::TexturePointer _normalTexture;
|
||||
|
||||
gpu::FramebufferPointer _downsampleFramebuffer;
|
||||
gpu::TexturePointer _halfLinearDepthTexture;
|
||||
|
|
@ -58,6 +59,7 @@ protected:
|
|||
glm::ivec2 _frameSize;
|
||||
glm::ivec2 _halfFrameSize;
|
||||
int _resolutionLevel{ 0 };
|
||||
bool _isStereo{ false };
|
||||
};
|
||||
|
||||
using LinearDepthFramebufferPointer = std::shared_ptr<LinearDepthFramebuffer>;
|
||||
|
|
@ -107,7 +109,7 @@ public:
|
|||
gpu::TexturePointer getBlurringTexture();
|
||||
|
||||
// Update the source framebuffer size which will drive the allocation of all the other resources.
|
||||
void updateLinearDepth(const gpu::TexturePointer& linearDepthBuffer);
|
||||
void update(const gpu::TexturePointer& linearDepthBuffer);
|
||||
gpu::TexturePointer getLinearDepthTexture();
|
||||
const glm::ivec2& getSourceFrameSize() const { return _frameSize; }
|
||||
|
||||
|
|
|
|||
|
|
@ -86,7 +86,10 @@
|
|||
// Ambient occlusion
|
||||
#define RENDER_UTILS_BUFFER_SSAO_PARAMS 2
|
||||
#define RENDER_UTILS_BUFFER_SSAO_DEBUG_PARAMS 3
|
||||
#define RENDER_UTILS_TEXTURE_SSAO_PYRAMID 1
|
||||
#define RENDER_UTILS_BUFFER_SSAO_BLUR_PARAMS 4
|
||||
#define RENDER_UTILS_BUFFER_SSAO_FRAME_PARAMS 5
|
||||
#define RENDER_UTILS_TEXTURE_SSAO_DEPTH 1
|
||||
#define RENDER_UTILS_TEXTURE_SSAO_NORMAL 2
|
||||
#define RENDER_UTILS_TEXTURE_SSAO_OCCLUSION 0
|
||||
|
||||
// Temporal anti-aliasing
|
||||
|
|
@ -120,7 +123,6 @@
|
|||
#define RENDER_UTILS_UNIFORM_TEXT_COLOR 0
|
||||
#define RENDER_UTILS_UNIFORM_TEXT_OUTLINE 1
|
||||
|
||||
|
||||
// Debugging
|
||||
#define RENDER_UTILS_BUFFER_DEBUG_SKYBOX 5
|
||||
#define RENDER_UTILS_DEBUG_TEXTURE0 11
|
||||
|
|
@ -144,7 +146,9 @@ enum Buffer {
|
|||
LightClusterContent = RENDER_UTILS_BUFFER_LIGHT_CLUSTER_CONTENT,
|
||||
SsscParams = RENDER_UTILS_BUFFER_SSSC_PARAMS,
|
||||
SsaoParams = RENDER_UTILS_BUFFER_SSAO_PARAMS,
|
||||
SsaoFrameParams = RENDER_UTILS_BUFFER_SSAO_FRAME_PARAMS,
|
||||
SsaoDebugParams = RENDER_UTILS_BUFFER_SSAO_DEBUG_PARAMS,
|
||||
SsaoBlurParams = RENDER_UTILS_BUFFER_SSAO_BLUR_PARAMS,
|
||||
LightIndex = RENDER_UTILS_BUFFER_LIGHT_INDEX,
|
||||
TaaParams = RENDER_UTILS_BUFFER_TAA_PARAMS,
|
||||
HighlightParams = RENDER_UTILS_BUFFER_HIGHLIGHT_PARAMS,
|
||||
|
|
@ -183,7 +187,8 @@ enum Texture {
|
|||
TaaDepth = RENDER_UTILS_TEXTURE_TAA_DEPTH,
|
||||
TaaNext = RENDER_UTILS_TEXTURE_TAA_NEXT,
|
||||
SsaoOcclusion = RENDER_UTILS_TEXTURE_SSAO_OCCLUSION,
|
||||
SsaoPyramid = RENDER_UTILS_TEXTURE_SSAO_PYRAMID,
|
||||
SsaoDepth = RENDER_UTILS_TEXTURE_SSAO_DEPTH,
|
||||
SsaoNormal = RENDER_UTILS_TEXTURE_SSAO_NORMAL,
|
||||
HighlightSceneDepth = RENDER_UTILS_TEXTURE_HIGHLIGHT_SCENE_DEPTH,
|
||||
HighlightDepth = RENDER_UTILS_TEXTURE_HIGHLIGHT_DEPTH,
|
||||
SurfaceGeometryDepth = RENDER_UTILS_TEXTURE_SG_DEPTH,
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
|
||||
|
|
@ -12,52 +12,94 @@
|
|||
<@def SSAO_SLH@>
|
||||
|
||||
<@include render-utils/ShaderConstants.h@>
|
||||
<@include ssao_shared.h@>
|
||||
|
||||
<@func declarePackOcclusionDepth()@>
|
||||
|
||||
const float FAR_PLANE_Z = -300.0;
|
||||
float CSZToDepthKey(float z) {
|
||||
return clamp(z * (-1.0 / SSAO_DEPTH_KEY_SCALE), 0.0, 1.0);
|
||||
}
|
||||
|
||||
float CSZToDephtKey(float z) {
|
||||
return clamp(z * (1.0 / FAR_PLANE_Z), 0.0, 1.0);
|
||||
}
|
||||
vec3 packOcclusionDepth(float occlusion, float depth) {
|
||||
vec4 packOcclusionOutput(float occlusion, float depth, vec3 eyeNormal) {
|
||||
depth = CSZToDepthKey(depth);
|
||||
#if SSAO_BILATERAL_BLUR_USE_NORMAL
|
||||
return vec4(occlusion, depth, eyeNormal.xy / eyeNormal.z);
|
||||
#else
|
||||
// Round to the nearest 1/256.0
|
||||
float temp = floor(depth * 256.0);
|
||||
return vec3(occlusion, temp * (1.0 / 256.0), depth * 256.0 - temp);
|
||||
depth *= 256.0;
|
||||
float temp = floor(depth);
|
||||
return vec4(occlusion, temp * (1.0 / 256.0), depth - temp, 0.0);
|
||||
#endif
|
||||
}
|
||||
vec2 unpackOcclusionDepth(vec3 raw) {
|
||||
float z = raw.y * (256.0 / 257.0) + raw.z * (1.0 / 257.0);
|
||||
return vec2(raw.x, z);
|
||||
|
||||
struct UnpackedOcclusion {
|
||||
vec3 normal;
|
||||
float depth;
|
||||
float occlusion;
|
||||
};
|
||||
|
||||
void unpackOcclusionOutput(vec4 raw, out UnpackedOcclusion result) {
|
||||
result.occlusion = raw.x;
|
||||
#if SSAO_BILATERAL_BLUR_USE_NORMAL
|
||||
result.depth = raw.y;
|
||||
result.normal = normalize(vec3(raw.zw, 1.0));
|
||||
#else
|
||||
result.depth = (raw.y + raw.z / 256.0);
|
||||
result.normal = vec3(0.0, 0.0, 1.0);
|
||||
#endif
|
||||
}
|
||||
|
||||
float unpackOcclusion(vec4 raw) {
|
||||
return raw.x;
|
||||
}
|
||||
|
||||
<@endfunc@>
|
||||
|
||||
<@func declareAmbientOcclusion()@>
|
||||
<@include DeferredTransform.slh@>
|
||||
<$declareDeferredFrameTransform()$>
|
||||
|
||||
struct AmbientOcclusionParams {
|
||||
vec4 _resolutionInfo;
|
||||
vec4 _radiusInfo;
|
||||
vec4 _ditheringInfo;
|
||||
vec4 _sampleInfo;
|
||||
vec4 _blurInfo;
|
||||
float _gaussianCoefs[8];
|
||||
};
|
||||
|
||||
LAYOUT(binding=RENDER_UTILS_BUFFER_SSAO_PARAMS) uniform ambientOcclusionParamsBuffer {
|
||||
AmbientOcclusionParams params;
|
||||
};
|
||||
|
||||
LAYOUT(binding=RENDER_UTILS_BUFFER_SSAO_FRAME_PARAMS) uniform ambientOcclusionFrameParamsBuffer {
|
||||
AmbientOcclusionFrameParams frameParams;
|
||||
};
|
||||
|
||||
float getPerspectiveScale() {
|
||||
|
||||
return (params._resolutionInfo.z);
|
||||
}
|
||||
int getResolutionLevel() {
|
||||
|
||||
int getResolutionLevel() {
|
||||
return int(params._resolutionInfo.x);
|
||||
}
|
||||
|
||||
bool isHorizonBased() {
|
||||
return params._resolutionInfo.y!=0.0;
|
||||
}
|
||||
|
||||
vec2 getNormalsSideSize() {
|
||||
return params._sideSizes[0].xy;
|
||||
}
|
||||
int getNormalsResolutionLevel() {
|
||||
return int(params._sideSizes[0].z);
|
||||
}
|
||||
int getDepthResolutionLevel() {
|
||||
return int(params._sideSizes[0].w);
|
||||
}
|
||||
vec2 getOcclusionSideSize() {
|
||||
return params._sideSizes[1].xy;
|
||||
}
|
||||
vec2 getOcclusionSplitSideSize() {
|
||||
return params._sideSizes[1].zw;
|
||||
}
|
||||
|
||||
ivec2 getWidthHeightRoundUp(int resolutionLevel) {
|
||||
ivec2 fullRes = ivec2(getWidthHeight(0));
|
||||
int resolutionDivisor = 1 << resolutionLevel;
|
||||
return (fullRes + resolutionDivisor - 1) / resolutionDivisor;
|
||||
}
|
||||
|
||||
float getRadius() {
|
||||
return params._radiusInfo.x;
|
||||
}
|
||||
|
|
@ -65,24 +107,35 @@ float getRadius2() {
|
|||
return params._radiusInfo.y;
|
||||
}
|
||||
float getInvRadius6() {
|
||||
return mix(params._radiusInfo.z, 1.0, isHorizonBased());
|
||||
}
|
||||
float getInvRadius2() {
|
||||
return params._radiusInfo.z;
|
||||
}
|
||||
|
||||
float getObscuranceScaling() {
|
||||
return params._radiusInfo.z * params._radiusInfo.w;
|
||||
return getInvRadius6() * params._radiusInfo.w;
|
||||
}
|
||||
|
||||
float isDitheringEnabled() {
|
||||
return params._ditheringInfo.x;
|
||||
}
|
||||
float getFrameDithering() {
|
||||
return params._ditheringInfo.y;
|
||||
}
|
||||
float isBorderingEnabled() {
|
||||
return params._ditheringInfo.w;
|
||||
}
|
||||
|
||||
float getFalloffBias() {
|
||||
return params._ditheringInfo.z;
|
||||
float getFalloffCosAngle() {
|
||||
return params._falloffInfo.x;
|
||||
}
|
||||
float getFalloffCosAngleScale() {
|
||||
return params._falloffInfo.y;
|
||||
}
|
||||
|
||||
float getFalloffSinAngle() {
|
||||
return params._falloffInfo.z;
|
||||
}
|
||||
float getFalloffSinAngleScale() {
|
||||
return params._falloffInfo.w;
|
||||
}
|
||||
|
||||
float getNumSamples() {
|
||||
|
|
@ -99,37 +152,6 @@ int doFetchMips() {
|
|||
return int(params._sampleInfo.w);
|
||||
}
|
||||
|
||||
float getBlurEdgeSharpness() {
|
||||
return params._blurInfo.x;
|
||||
}
|
||||
|
||||
#ifdef CONSTANT_GAUSSIAN
|
||||
const int BLUR_RADIUS = 4;
|
||||
const float gaussian[BLUR_RADIUS + 1] =
|
||||
// KEEP this dead code for eventual performance improvment
|
||||
// float[](0.356642, 0.239400, 0.072410, 0.009869);
|
||||
// float[](0.398943, 0.241971, 0.053991, 0.004432, 0.000134); // stddev = 1.0
|
||||
float[](0.153170, 0.144893, 0.122649, 0.092902, 0.062970); // stddev = 2.0
|
||||
//float[](0.197413, 0.17467, 0.12098,0.065591,0.040059);
|
||||
// float[](0.111220, 0.107798, 0.098151, 0.083953, 0.067458, 0.050920, 0.036108); // stddev = 3.0
|
||||
|
||||
int getBlurRadius() {
|
||||
return BLUR_RADIUS;
|
||||
}
|
||||
|
||||
float getBlurCoef(int c) {
|
||||
return gaussian[c];
|
||||
}
|
||||
#else
|
||||
int getBlurRadius() {
|
||||
return int(params._blurInfo.y);
|
||||
}
|
||||
|
||||
float getBlurCoef(int c) {
|
||||
return params._gaussianCoefs[c];
|
||||
}
|
||||
#endif
|
||||
|
||||
<@endfunc@>
|
||||
|
||||
<@func declareSamplingDisk()@>
|
||||
|
|
@ -139,43 +161,57 @@ float getAngleDitheringWorldPos(in vec3 pixelWorldPos) {
|
|||
|
||||
ivec3 pixelPos = ivec3(worldPosFract * 256.0);
|
||||
|
||||
return isDitheringEnabled() * float(((3 * pixelPos.x ^ pixelPos.y + pixelPos.x * pixelPos.y) + (3 * pixelPos.y ^ pixelPos.z + pixelPos.x * pixelPos.z)) * 10) + getFrameDithering();
|
||||
return isDitheringEnabled() * float(((3 * pixelPos.x ^ pixelPos.y + pixelPos.x * pixelPos.y) + (3 * pixelPos.y ^ pixelPos.z + pixelPos.x * pixelPos.z)) * 10);
|
||||
}
|
||||
|
||||
float getAngleDitheringSplit() {
|
||||
return isDitheringEnabled() * frameParams._angleInfo.x;
|
||||
}
|
||||
|
||||
float getAngleDithering(in ivec2 pixelPos) {
|
||||
#if SSAO_USE_QUAD_SPLIT
|
||||
return getAngleDitheringSplit();
|
||||
#else
|
||||
// Hash function used in the AlchemyAO paper
|
||||
return isDitheringEnabled() * float((3 * pixelPos.x ^ pixelPos.y + pixelPos.x * pixelPos.y) * 10) + getFrameDithering();
|
||||
return getAngleDitheringPixelPos(pixelPos);
|
||||
#endif
|
||||
}
|
||||
|
||||
float evalDiskRadius(float Zeye, vec2 imageSize) {
|
||||
float getAngleDitheringPixelPos(in ivec2 pixelPos) {
|
||||
// Hash function used in the AlchemyAO paper
|
||||
return isDitheringEnabled() * float((3 * pixelPos.x ^ pixelPos.y + pixelPos.x * pixelPos.y) * 10);
|
||||
}
|
||||
|
||||
float evalDiskRadius(float Zeye, vec2 sideImageSize) {
|
||||
// Choose the screen-space sample radius
|
||||
// proportional to the projected area of the sphere
|
||||
float ssDiskRadius = -( getProjScale(getResolutionLevel()) * getRadius() / Zeye ) * getPerspectiveScale();
|
||||
float diskPixelRadius = -( getProjScale(getResolutionLevel()) * getRadius() / Zeye ) * getPerspectiveScale();
|
||||
|
||||
// clamp the disk to fit in the image otherwise too many unknown
|
||||
ssDiskRadius = min(ssDiskRadius, imageSize.y * 0.5);
|
||||
diskPixelRadius = min(diskPixelRadius, sideImageSize.y * 0.5);
|
||||
|
||||
return ssDiskRadius;
|
||||
return diskPixelRadius;
|
||||
}
|
||||
|
||||
const float TWO_PI = 6.28;
|
||||
const float PI = 3.1415926;
|
||||
const float TWO_PI = 6.2831852;
|
||||
|
||||
vec3 getUnitTapLocation(int sampleNumber, float spinAngle){
|
||||
vec3 getUnitTapLocation(int sampleNumber, float spiralTurns, float spinAngle, float angleRange){
|
||||
// Radius relative to ssR
|
||||
float alpha = (float(sampleNumber) + 0.5) * getInvNumSamples();
|
||||
float angle = alpha * (getNumSpiralTurns() * TWO_PI) + spinAngle;
|
||||
float alpha = float(sampleNumber) * getInvNumSamples();
|
||||
float angle = alpha * (spiralTurns * angleRange) + spinAngle;
|
||||
return vec3(cos(angle), sin(angle), alpha);
|
||||
}
|
||||
|
||||
vec3 getTapLocation(int sampleNumber, float spinAngle, float outerRadius) {
|
||||
vec3 tap = getUnitTapLocation(sampleNumber, spinAngle);
|
||||
vec3 getTapLocationSSAO(int sampleNumber, float spinAngle, float outerRadius) {
|
||||
vec3 tap = getUnitTapLocation(sampleNumber, getNumSpiralTurns(), spinAngle, TWO_PI);
|
||||
tap.xy *= tap.z;
|
||||
tap *= outerRadius;
|
||||
return tap;
|
||||
}
|
||||
|
||||
vec3 getTapLocationClamped(int sampleNumber, float spinAngle, float outerRadius, vec2 pixelPos, vec2 imageSize) {
|
||||
vec3 tap = getTapLocation(sampleNumber, spinAngle, outerRadius);
|
||||
vec3 getTapLocationClampedSSAO(int sampleNumber, float spinAngle, float outerRadius, vec2 pixelPos, vec2 sideImageSize) {
|
||||
vec3 tap = getTapLocationSSAO(sampleNumber, spinAngle, outerRadius);
|
||||
vec2 tapPos = pixelPos + tap.xy;
|
||||
|
||||
if (!(isBorderingEnabled() > 0.0)) {
|
||||
|
|
@ -186,36 +222,19 @@ vec3 getTapLocationClamped(int sampleNumber, float spinAngle, float outerRadius,
|
|||
if ((tapPos.x < 0.5)) {
|
||||
tapPos.x = -tapPos.x;
|
||||
redoTap = true;
|
||||
} else if ((tapPos.x > imageSize.x - 0.5)) {
|
||||
tapPos.x -= (imageSize.x - tapPos.x);
|
||||
} else if ((tapPos.x > sideImageSize.x - 0.5)) {
|
||||
tapPos.x -= (sideImageSize.x - tapPos.x);
|
||||
redoTap = true;
|
||||
}
|
||||
|
||||
if ((tapPos.y < 0.5)) {
|
||||
tapPos.y = -tapPos.y;
|
||||
redoTap = true;
|
||||
} else if ((tapPos.y > imageSize.y - 0.5)) {
|
||||
tapPos.y -= (imageSize.y - tapPos.y);
|
||||
redoTap = true;
|
||||
}
|
||||
/*
|
||||
if ((tapPos.x < 0.5)) {
|
||||
tapPos.x = 0.5;
|
||||
redoTap = true;
|
||||
} else if ((tapPos.x > imageSize.x - 0.5)) {
|
||||
tapPos.x = imageSize.x - 0.5;
|
||||
} else if ((tapPos.y > sideImageSize.y - 0.5)) {
|
||||
tapPos.y -= (sideImageSize.y - tapPos.y);
|
||||
redoTap = true;
|
||||
}
|
||||
|
||||
if ((tapPos.y < 0.5)) {
|
||||
tapPos.y = 0.5;
|
||||
redoTap = true;
|
||||
} else if ((tapPos.y > imageSize.y - 0.5)) {
|
||||
tapPos.y = imageSize.y - 0.5;
|
||||
redoTap = true;
|
||||
}
|
||||
*/
|
||||
|
||||
if (redoTap) {
|
||||
tap.xy = tapPos - pixelPos;
|
||||
tap.z = length(tap.xy);
|
||||
|
|
@ -230,156 +249,341 @@ vec3 getTapLocationClamped(int sampleNumber, float spinAngle, float outerRadius,
|
|||
|
||||
<@func declareFetchDepthPyramidMap()@>
|
||||
|
||||
|
||||
// the depth pyramid texture
|
||||
LAYOUT(binding=RENDER_UTILS_TEXTURE_SSAO_PYRAMID) uniform sampler2D pyramidMap;
|
||||
LAYOUT(binding=RENDER_UTILS_TEXTURE_SSAO_DEPTH) uniform sampler2D depthPyramidTex;
|
||||
LAYOUT(binding=RENDER_UTILS_TEXTURE_SSAO_NORMAL) uniform sampler2D normalTex;
|
||||
|
||||
float getZEye(ivec2 pixel, int level) {
|
||||
return -texelFetch(pyramidMap, pixel, level).x;
|
||||
vec2 getFramebufferUVFromSideUV(ivec4 side, vec2 uv) {
|
||||
return mix(uv, vec2((uv.x + float(getStereoSide(side))) * 0.5, uv.y), float(isStereo()));
|
||||
}
|
||||
|
||||
vec2 getSideUVFromFramebufferUV(ivec4 side, vec2 uv) {
|
||||
return mix(uv, vec2(uv.x * 2.0 - float(getStereoSide(side)), uv.y), float(isStereo()));
|
||||
}
|
||||
|
||||
vec2 getDepthTextureSize(int level) {
|
||||
return vec2(textureSize(depthPyramidTex, level));
|
||||
}
|
||||
|
||||
vec2 getDepthTextureSideSize(int level) {
|
||||
ivec2 size = textureSize(depthPyramidTex, level);
|
||||
size.x >>= int(isStereo()) & 1;
|
||||
return vec2(size);
|
||||
}
|
||||
|
||||
vec2 getStereoSideSizeRoundUp(int resolutionLevel) {
|
||||
ivec2 fullRes = ivec2(getStereoSideSize(0));
|
||||
int resolutionDivisor = 1 << resolutionLevel;
|
||||
return vec2((fullRes + resolutionDivisor - 1) / resolutionDivisor);
|
||||
}
|
||||
|
||||
float getZEyeAtUV(vec2 texCoord, float level) {
|
||||
return -textureLod(depthPyramidTex, texCoord, level).x;
|
||||
}
|
||||
|
||||
<@func getZEyeAtUVOffset(texCoord, level, texelOffset)@>
|
||||
-textureLodOffset(depthPyramidTex, <$texCoord$>, <$level$>, <$texelOffset$>).x;
|
||||
<@endfunc@>
|
||||
|
||||
float getZEyeAtUV(ivec4 side, vec2 texCoord, float level) {
|
||||
texCoord = getFramebufferUVFromSideUV(side, texCoord);
|
||||
return getZEyeAtUV(texCoord, level);
|
||||
}
|
||||
|
||||
vec3 packNormal(vec3 normal) {
|
||||
vec3 absNormal = abs(normal);
|
||||
return 0.5 + normal * 0.5 / max(absNormal.x, max(absNormal.y, absNormal.z));
|
||||
}
|
||||
|
||||
vec3 unpackNormal(vec3 packedNormal) {
|
||||
return normalize(packedNormal*2.0 - 1.0);
|
||||
}
|
||||
|
||||
vec3 getNormalEyeAtUV(vec2 texCoord, float level) {
|
||||
return unpackNormal(textureLod(normalTex, texCoord, level).xyz);
|
||||
}
|
||||
|
||||
vec3 getNormalEyeAtUV(ivec4 side, vec2 texCoord, float level) {
|
||||
texCoord = getFramebufferUVFromSideUV(side, texCoord);
|
||||
return getNormalEyeAtUV(texCoord, level);
|
||||
}
|
||||
|
||||
vec2 snapToTexel(vec2 uv, vec2 pixelSize) {
|
||||
return (floor(uv * pixelSize - 0.5) + 0.5) / pixelSize;
|
||||
}
|
||||
|
||||
const int LOG_MAX_OFFSET = 3;
|
||||
const int MAX_MIP_LEVEL = 5;
|
||||
int evalMipFromRadius(float radius) {
|
||||
// mipLevel = floor(log(ssR / MAX_OFFSET));
|
||||
const int LOG_MAX_OFFSET = 2;
|
||||
const int MAX_MIP_LEVEL = 5;
|
||||
return clamp(findMSB(int(radius)) - LOG_MAX_OFFSET, 0, MAX_MIP_LEVEL);
|
||||
}
|
||||
|
||||
vec2 fetchTap(ivec4 side, vec2 tapUV, float tapRadius) {
|
||||
int mipLevel = evalMipFromRadius(tapRadius * float(doFetchMips()));
|
||||
|
||||
vec3 fetchTapUnfiltered(ivec4 side, ivec2 ssC, vec3 tap, vec2 imageSize) {
|
||||
ivec2 ssP = ivec2(tap.xy) + ssC;
|
||||
ivec2 ssPFull = ivec2(ssP.x + side.y, ssP.y);
|
||||
vec2 fetchUV = clamp(tapUV, vec2(0), vec2(1));
|
||||
fetchUV = getFramebufferUVFromSideUV(side, fetchUV);
|
||||
|
||||
|
||||
vec2 tapUV = (vec2(ssP) + vec2(0.5)) / imageSize;
|
||||
|
||||
vec2 fetchUV = vec2(tapUV.x + float(side.w) * 0.5 * (float(side.x) - tapUV.x), tapUV.y);
|
||||
|
||||
vec3 P;
|
||||
P.xy = tapUV;
|
||||
P.z = -texture(pyramidMap, fetchUV).x;
|
||||
|
||||
return P;
|
||||
vec2 P;
|
||||
P.x = float(mipLevel);
|
||||
P.y = -textureLod(depthPyramidTex, fetchUV, P.x).x;
|
||||
return P;
|
||||
}
|
||||
|
||||
vec3 fetchTap(ivec4 side, ivec2 ssC, vec3 tap, vec2 imageSize) {
|
||||
int mipLevel = evalMipFromRadius(tap.z * float(doFetchMips()));
|
||||
|
||||
ivec2 ssP = ivec2(tap.xy) + ssC;
|
||||
ivec2 ssPFull = ivec2(ssP.x + side.y, ssP.y);
|
||||
|
||||
// We need to divide by 2^mipLevel to read the appropriately scaled coordinate from a MIP-map.
|
||||
// Manually clamp to the texture size because texelFetch bypasses the texture unit
|
||||
// ivec2 mipSize = textureSize(pyramidMap, mipLevel);
|
||||
ivec2 mipSize = max(ivec2(imageSize) >> mipLevel, ivec2(1));
|
||||
|
||||
ivec2 mipP = clamp(ssPFull >> mipLevel, ivec2(0), mipSize - ivec2(1));
|
||||
|
||||
vec2 tapUV = (vec2(ssP) + vec2(0.5)) / imageSize;
|
||||
vec2 fetchUV = vec2(tapUV.x + float(side.w) * 0.5 * (float(side.x) - tapUV.x), tapUV.y);
|
||||
// vec2 tapUV = (vec2(mipP) + vec2(0.5)) / vec2(mipSize);
|
||||
|
||||
vec3 P;
|
||||
P.xy = tapUV;
|
||||
// P.z = -texelFetch(pyramidMap, mipP, mipLevel).x;
|
||||
P.z = -textureLod(pyramidMap, fetchUV, float(mipLevel)).x;
|
||||
|
||||
return P;
|
||||
vec3 buildPosition(ivec4 side, vec2 fragUVPos) {
|
||||
float Zeye = getZEyeAtUV(side, fragUVPos, 0.0);
|
||||
return evalEyePositionFromZeye(side.x, Zeye, fragUVPos);
|
||||
}
|
||||
|
||||
<@func buildPositionOffset(side, fragUVPos, sideFragUVPos, texelOffset, deltaUV, position)@>
|
||||
{
|
||||
float Zeye = <$getZEyeAtUVOffset($sideFragUVPos$, 0.0, $texelOffset$)$>
|
||||
<$position$> = evalEyePositionFromZeye(<$side$>.x, Zeye, <$fragUVPos$> + vec2(<$texelOffset$>)*<$deltaUV$>);
|
||||
}
|
||||
<@endfunc@>
|
||||
|
||||
vec3 getMinDelta(vec3 centralPoint, vec3 offsetPointPos, vec3 offsetPointNeg) {
|
||||
vec3 delta0 = offsetPointPos - centralPoint;
|
||||
vec3 delta1 = centralPoint - offsetPointNeg;
|
||||
float sqrLength0 = dot(delta0, delta0);
|
||||
float sqrLength1 = dot(delta1, delta1);
|
||||
|
||||
return mix(delta1, delta0, float(sqrLength0 < sqrLength1));
|
||||
}
|
||||
|
||||
const ivec2 UV_RIGHT = ivec2(1,0);
|
||||
const ivec2 UV_LEFT = ivec2(-1,0);
|
||||
const ivec2 UV_TOP = ivec2(0,1);
|
||||
const ivec2 UV_BOTTOM = ivec2(0,-1);
|
||||
|
||||
vec3 buildNormal(ivec4 side, vec2 fragUVPos, vec3 fragPosition, vec2 deltaDepthUV) {
|
||||
vec2 fullUVPos = getFramebufferUVFromSideUV(side, fragUVPos);
|
||||
|
||||
vec3 fragPositionDxPos;
|
||||
vec3 fragPositionDxNeg;
|
||||
vec3 fragPositionDyPos;
|
||||
vec3 fragPositionDyNeg;
|
||||
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_RIGHT, deltaDepthUV, fragPositionDxPos)$>
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_LEFT, deltaDepthUV, fragPositionDxNeg)$>
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_TOP, deltaDepthUV, fragPositionDyPos)$>
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_BOTTOM, deltaDepthUV, fragPositionDyNeg)$>
|
||||
|
||||
vec3 fragDeltaDx = getMinDelta(fragPosition, fragPositionDxPos, fragPositionDxNeg);
|
||||
vec3 fragDeltaDy = getMinDelta(fragPosition, fragPositionDyPos, fragPositionDyNeg);
|
||||
|
||||
return normalize( cross(fragDeltaDx, fragDeltaDy) );
|
||||
}
|
||||
|
||||
void buildTangentBinormal(ivec4 side, vec2 fragUVPos, vec3 fragPosition, vec3 fragNormal, vec2 deltaDepthUV,
|
||||
out vec3 fragTangent, out vec3 fragBinormal) {
|
||||
vec2 fullUVPos = getFramebufferUVFromSideUV(side, fragUVPos);
|
||||
|
||||
vec3 fragPositionDxPos;
|
||||
vec3 fragPositionDxNeg;
|
||||
vec3 fragPositionDyPos;
|
||||
vec3 fragPositionDyNeg;
|
||||
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_RIGHT, deltaDepthUV, fragPositionDxPos)$>
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_LEFT, deltaDepthUV, fragPositionDxNeg)$>
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_TOP, deltaDepthUV, fragPositionDyPos)$>
|
||||
<$buildPositionOffset(side, fragUVPos, fullUVPos, UV_BOTTOM, deltaDepthUV, fragPositionDyNeg)$>
|
||||
|
||||
vec3 fragDeltaDx = getMinDelta(fragPosition, fragPositionDxPos, fragPositionDxNeg);
|
||||
vec3 fragDeltaDy = getMinDelta(fragPosition, fragPositionDyPos, fragPositionDyNeg);
|
||||
|
||||
//fragTangent = normalize( cross(fragDeltaDy, fragNormal) );
|
||||
//fragBinormal = normalize( cross(fragNormal, fragDeltaDx) );
|
||||
|
||||
fragTangent = fragDeltaDx;
|
||||
fragBinormal = fragDeltaDy;
|
||||
}
|
||||
|
||||
<@endfunc@>
|
||||
|
||||
|
||||
<@func declareEvalObscurance()@>
|
||||
|
||||
float evalAO(in vec3 C, in vec3 n_C, in vec3 Q) {
|
||||
vec3 v = Q - C;
|
||||
float vv = dot(v, v);
|
||||
float vn = dot(v, n_C);
|
||||
struct TBNFrame {
|
||||
vec3 tangent;
|
||||
vec3 binormal;
|
||||
vec3 normal;
|
||||
};
|
||||
|
||||
// Fall off function as recommended in SAO paper
|
||||
vec3 fastAcos(vec3 x) {
|
||||
// [Eberly2014] GPGPU Programming for Games and Science
|
||||
vec3 absX = abs(x);
|
||||
vec3 res = absX * (-0.156583) + vec3(PI / 2.0);
|
||||
res *= sqrt(vec3(1.0) - absX);
|
||||
return mix(res, vec3(PI) - res, greaterThanEqual(x, vec3(0)));
|
||||
}
|
||||
|
||||
float evalVisibilitySSAO(in vec3 centerPosition, in vec3 centerNormal, in vec3 tapPosition) {
|
||||
vec3 v = tapPosition - centerPosition;
|
||||
float vv = dot(v, v);
|
||||
float vn = dot(v, centerNormal);
|
||||
|
||||
// Falloff function as recommended in SSAO paper
|
||||
const float epsilon = 0.01;
|
||||
float f = max(getRadius2() - vv, 0.0);
|
||||
return f * f * f * max((vn - getFalloffBias()) / (epsilon + vv), 0.0);
|
||||
return f * f * f * max((vn - getFalloffCosAngle()) / (epsilon + vv), 0.0);
|
||||
}
|
||||
|
||||
#define HBAO_USE_COS_ANGLE 1
|
||||
#define HBAO_USE_OVERHANG_HACK 0
|
||||
|
||||
float computeWeightForHorizon(float horizonLimit, float distanceSquared) {
|
||||
return max(0.0, 1.0 - distanceSquared * getInvRadius2());
|
||||
}
|
||||
|
||||
float computeWeightedHorizon(float horizonLimit, float distanceSquared) {
|
||||
float radiusFalloff = computeWeightForHorizon(horizonLimit, distanceSquared);
|
||||
|
||||
#if !HBAO_USE_COS_ANGLE
|
||||
horizonLimit = getFalloffSinAngle() - horizonLimit;
|
||||
#endif
|
||||
horizonLimit *= radiusFalloff;
|
||||
#if !HBAO_USE_COS_ANGLE
|
||||
horizonLimit = getFalloffSinAngle() - horizonLimit;
|
||||
#endif
|
||||
|
||||
return horizonLimit;
|
||||
}
|
||||
|
||||
<@func computeHorizon()@>
|
||||
if (tapUVPos.x<0.0 || tapUVPos.y<0.0 || tapUVPos.x>=1.0 || tapUVPos.y>=1.0) {
|
||||
// Early exit because we've hit the borders of the frame
|
||||
break;
|
||||
}
|
||||
vec2 tapMipZ = fetchTap(side, tapUVPos, radius);
|
||||
vec3 tapPositionES = evalEyePositionFromZeye(side.x, tapMipZ.y, tapUVPos);
|
||||
vec3 deltaVec = tapPositionES - fragPositionES;
|
||||
float distanceSquared = dot(deltaVec, deltaVec);
|
||||
float deltaDotNormal = dot(deltaVec, fragFrameES.normal);
|
||||
#if HBAO_USE_COS_ANGLE
|
||||
float tapHorizonLimit = deltaDotNormal;
|
||||
#else
|
||||
float tapHorizonLimit = dot(deltaVec, fragFrameES.tangent);
|
||||
#endif
|
||||
tapHorizonLimit *= inversesqrt(distanceSquared);
|
||||
|
||||
if (distanceSquared < getRadius2() && deltaDotNormal>0.0) {
|
||||
#if HBAO_USE_COS_ANGLE
|
||||
float weight = computeWeightForHorizon(tapHorizonLimit, distanceSquared);
|
||||
if (tapHorizonLimit > horizonLimit) {
|
||||
occlusion += weight * (tapHorizonLimit - horizonLimit);
|
||||
horizonLimit = tapHorizonLimit;
|
||||
}
|
||||
#if HBAO_USE_OVERHANG_HACK
|
||||
else if (dot(deltaVec, fragFrameES.tangent) < 0.0) {
|
||||
// This is a hack to try to handle the case where the occlusion angle is
|
||||
// greater than 90°
|
||||
occlusion = mix(occlusion, (occlusion+1.0) * 0.5, weight);
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
if (tapHorizonLimit < horizonLimit) {
|
||||
tapHorizonLimit = computeWeightedHorizon(tapHorizonLimit, distanceSquared);
|
||||
horizonLimit = min(horizonLimit, tapHorizonLimit);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
<@endfunc@>
|
||||
|
||||
<@func declareBlurPass(axis)@>
|
||||
#define HBAO_HORIZON_SEARCH_CONSTANT_STEP 0
|
||||
|
||||
<$declarePackOcclusionDepth()$>
|
||||
<$declareAmbientOcclusion()$>
|
||||
float computeOcclusion(ivec4 side, vec2 fragUVPos, vec3 fragPositionES, TBNFrame fragFrameES, vec2 searchDir, float searchRadius, int stepCount) {
|
||||
float occlusion = 0.0;
|
||||
#if HBAO_USE_COS_ANGLE
|
||||
float horizonLimit = getFalloffCosAngle();
|
||||
#else
|
||||
float horizonLimit = getFalloffSinAngle();
|
||||
#endif
|
||||
|
||||
// the source occlusion texture
|
||||
LAYOUT(binding=RENDER_UTILS_TEXTURE_SSAO_OCCLUSION) uniform sampler2D occlusionMap;
|
||||
if (stepCount>0) {
|
||||
vec2 deltaTapUV = searchDir / float(stepCount);
|
||||
vec2 tapUVPos;
|
||||
float deltaRadius = searchRadius / float(stepCount);
|
||||
vec2 sideDepthSize = getDepthTextureSideSize(0);
|
||||
|
||||
vec2 fetchOcclusionDepthRaw(ivec2 coords, out vec3 raw) {
|
||||
raw = texelFetch(occlusionMap, coords, 0).xyz;
|
||||
return unpackOcclusionDepth(raw);
|
||||
}
|
||||
#if HBAO_HORIZON_SEARCH_CONSTANT_STEP
|
||||
float radius = 0.0;
|
||||
int stepIndex;
|
||||
|
||||
vec2 fetchOcclusionDepth(ivec2 coords) {
|
||||
return unpackOcclusionDepth(texelFetch(occlusionMap, coords, 0).xyz);
|
||||
}
|
||||
for (stepIndex=0 ; stepIndex<stepCount ; stepIndex++) {
|
||||
fragUVPos += deltaTapUV;
|
||||
radius += deltaRadius;
|
||||
tapUVPos = snapToTexel(fragUVPos, sideDepthSize);
|
||||
|
||||
const int RADIUS_SCALE = 1;
|
||||
const float BLUR_WEIGHT_OFFSET = 0.05;
|
||||
const float BLUR_EDGE_SCALE = 2000.0;
|
||||
<$computeHorizon()$>
|
||||
}
|
||||
#else
|
||||
// Step is adapted to Mip level
|
||||
float radius = deltaRadius;
|
||||
float mipLevel = float(evalMipFromRadius(radius * float(doFetchMips())));
|
||||
|
||||
vec2 evalTapWeightedValue(ivec3 side, int r, ivec2 ssC, float key) {
|
||||
ivec2 tapOffset = <$axis$> * (r * RADIUS_SCALE);
|
||||
ivec2 ssP = (ssC + tapOffset);
|
||||
while (radius<=searchRadius) {
|
||||
fragUVPos += deltaTapUV;
|
||||
tapUVPos = snapToTexel(fragUVPos, sideDepthSize);
|
||||
|
||||
if ((ssP.x < side.y || ssP.x >= side.z + side.y) || (ssP.y < 0 || ssP.y >= int(getWidthHeight(getResolutionLevel()).y))) {
|
||||
return vec2(0.0);
|
||||
}
|
||||
vec2 tapOZ = fetchOcclusionDepth(ssC + tapOffset);
|
||||
<$computeHorizon()$>
|
||||
|
||||
// spatial domain: offset gaussian tap
|
||||
float weight = BLUR_WEIGHT_OFFSET + getBlurCoef(abs(r));
|
||||
|
||||
// range domain (the "bilateral" weight). As depth difference increases, decrease weight.
|
||||
weight *= max(0.0, 1.0 - (getBlurEdgeSharpness() * BLUR_EDGE_SCALE) * abs(tapOZ.y - key));
|
||||
|
||||
return vec2(tapOZ.x * weight, weight);
|
||||
}
|
||||
|
||||
vec3 getBlurredOcclusion(vec2 coord) {
|
||||
ivec2 ssC = ivec2(coord);
|
||||
|
||||
// Stereo side info
|
||||
ivec4 side = getStereoSideInfo(ssC.x, getResolutionLevel());
|
||||
|
||||
vec3 rawSample;
|
||||
vec2 occlusionDepth = fetchOcclusionDepthRaw(ssC, rawSample);
|
||||
float key = occlusionDepth.y;
|
||||
|
||||
// Central pixel contribution
|
||||
float mainWeight = getBlurCoef(0);
|
||||
vec2 weightedSums = vec2(occlusionDepth.x * mainWeight, mainWeight);
|
||||
|
||||
// Accumulate weighted contributions along the bluring axis in the [-radius, radius] range
|
||||
int blurRadius = getBlurRadius();
|
||||
// negative side first
|
||||
for (int r = -blurRadius; r <= -1; ++r) {
|
||||
weightedSums += evalTapWeightedValue(side.xyz, r, ssC, key);
|
||||
}
|
||||
// then positive side
|
||||
for (int r = 1; r <= blurRadius; ++r) {
|
||||
weightedSums += evalTapWeightedValue(side.xyz, r, ssC, key);
|
||||
if (tapMipZ.x != mipLevel) {
|
||||
mipLevel = tapMipZ.x;
|
||||
deltaRadius *= 2.0;
|
||||
deltaTapUV *= 2.0;
|
||||
sideDepthSize = getDepthTextureSideSize(int(mipLevel));
|
||||
}
|
||||
radius += deltaRadius;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Final normalization
|
||||
const float epsilon = 0.0001;
|
||||
float result = weightedSums.x / (weightedSums.y + epsilon);
|
||||
|
||||
rawSample.x = result;
|
||||
return rawSample;
|
||||
#if HBAO_USE_COS_ANGLE
|
||||
occlusion = min(occlusion * getFalloffCosAngleScale(), 1.0);
|
||||
#else
|
||||
occlusion = horizonLimit * mix(1.0, getFalloffSinAngleScale(), horizonLimit > 0.0);
|
||||
#endif
|
||||
|
||||
return occlusion;
|
||||
}
|
||||
|
||||
float evalVisibilityHBAO(ivec4 side, vec2 fragUVPos, vec2 invSideImageSize, vec2 deltaTap, float diskPixelRadius,
|
||||
vec3 fragPositionES, vec3 fragNormalES) {
|
||||
vec2 pixelSearchVec = deltaTap * diskPixelRadius;
|
||||
vec2 searchDir = pixelSearchVec * invSideImageSize;
|
||||
vec2 deltaTapUV = deltaTap * invSideImageSize;
|
||||
float obscuranceH1 = 0.0;
|
||||
float obscuranceH2 = 0.0;
|
||||
pixelSearchVec = abs(pixelSearchVec);
|
||||
int stepCount = int(ceil(max(pixelSearchVec.x, pixelSearchVec.y)));
|
||||
TBNFrame fragFrameES;
|
||||
|
||||
fragFrameES.tangent = vec3(0.0);
|
||||
fragFrameES.binormal = vec3(0.0);
|
||||
fragFrameES.normal = fragNormalES;
|
||||
|
||||
#if HBAO_USE_OVERHANG_HACK || !HBAO_USE_COS_ANGLE
|
||||
vec3 positionPos = buildPosition(side, fragUVPos + deltaTapUV);
|
||||
vec3 positionNeg = buildPosition(side, fragUVPos - deltaTapUV);
|
||||
|
||||
fragFrameES.tangent = getMinDelta(fragPositionES, positionPos, positionNeg);
|
||||
fragFrameES.tangent -= dot(fragNormalES, fragFrameES.tangent) * fragNormalES;
|
||||
fragFrameES.tangent = normalize(fragFrameES.tangent);
|
||||
#endif
|
||||
// Forward search for h1
|
||||
obscuranceH1 = computeOcclusion(side, fragUVPos, fragPositionES, fragFrameES, searchDir, diskPixelRadius, stepCount);
|
||||
|
||||
// Backward search for h2
|
||||
#if HBAO_USE_OVERHANG_HACK || !HBAO_USE_COS_ANGLE
|
||||
fragFrameES.tangent = -fragFrameES.tangent;
|
||||
#endif
|
||||
obscuranceH2 = computeOcclusion(side, fragUVPos, fragPositionES, fragFrameES, -searchDir, diskPixelRadius, stepCount);
|
||||
|
||||
return obscuranceH1 + obscuranceH2;
|
||||
}
|
||||
|
||||
<@endfunc@>
|
||||
|
||||
|
||||
<@endif@>
|
||||
<@endif@>
|
||||
|
|
|
|||
135
libraries/render-utils/src/ssao_bilateralBlur.slf
Normal file
135
libraries/render-utils/src/ssao_bilateralBlur.slf
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
<@include gpu/Config.slh@>
|
||||
<$VERSION_HEADER$>
|
||||
// Generated on <$_SCRIBE_DATE$>
|
||||
//
|
||||
// ssao_bilateralBlur.frag
|
||||
//
|
||||
// Created by Sam Gateau on 1/1/16.
|
||||
// Copyright 2016 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 ssao.slh@>
|
||||
|
||||
// Hack comment
|
||||
|
||||
<$declareAmbientOcclusion()$>
|
||||
<$declareFetchDepthPyramidMap()$>
|
||||
<$declarePackOcclusionDepth()$>
|
||||
|
||||
// the source occlusion texture
|
||||
LAYOUT(binding=RENDER_UTILS_TEXTURE_SSAO_OCCLUSION) uniform sampler2D occlusionMap;
|
||||
|
||||
LAYOUT(binding=RENDER_UTILS_BUFFER_SSAO_BLUR_PARAMS) uniform blurParamsBuffer {
|
||||
AmbientOcclusionBlurParams blurParams;
|
||||
};
|
||||
|
||||
vec2 getBlurOcclusionAxis() {
|
||||
return blurParams._blurAxis.xy;
|
||||
}
|
||||
|
||||
vec2 getBlurOcclusionUVLimit() {
|
||||
return blurParams._blurAxis.zw;
|
||||
}
|
||||
|
||||
vec3 getBlurScales() {
|
||||
return blurParams._blurInfo.xyz;
|
||||
}
|
||||
|
||||
int getBlurRadius() {
|
||||
return int(blurParams._blurInfo.w);
|
||||
}
|
||||
|
||||
vec4 fetchOcclusionPacked(ivec4 side, vec2 texCoord) {
|
||||
texCoord.x = isStereo() ? (texCoord.x + float(getStereoSide(side)) * getBlurOcclusionUVLimit().x) * 0.5 : texCoord.x;
|
||||
return textureLod(occlusionMap, texCoord, 0.0);
|
||||
}
|
||||
|
||||
float evalBlurCoefficient(vec3 blurScales, float radialDistance, float zDistance, float normalDistance) {
|
||||
vec3 distances = vec3(radialDistance, zDistance, normalDistance);
|
||||
return exp2(dot(blurScales, distances*distances));
|
||||
}
|
||||
|
||||
const float BLUR_EDGE_NORMAL_LIMIT = 0.25;
|
||||
|
||||
vec2 evalTapWeightedValue(vec3 blurScales, ivec4 side, int r, vec2 occlusionTexCoord, float fragDepth, vec3 fragNormal) {
|
||||
vec2 occlusionTexCoordLimits = getBlurOcclusionUVLimit();
|
||||
|
||||
if (any(lessThan(occlusionTexCoord, vec2(0.0))) || any(greaterThanEqual(occlusionTexCoord, occlusionTexCoordLimits)) ) {
|
||||
return vec2(0.0);
|
||||
}
|
||||
|
||||
vec4 tapOcclusionPacked = fetchOcclusionPacked(side, occlusionTexCoord);
|
||||
UnpackedOcclusion tap;
|
||||
unpackOcclusionOutput(tapOcclusionPacked, tap);
|
||||
|
||||
// range domain (the "bilateral" weight). As depth difference increases, decrease weight.
|
||||
float zDistance = tap.depth - fragDepth;
|
||||
#if SSAO_BILATERAL_BLUR_USE_NORMAL
|
||||
float normalDistance = BLUR_EDGE_NORMAL_LIMIT - min(BLUR_EDGE_NORMAL_LIMIT, dot(tap.normal, fragNormal));
|
||||
#else
|
||||
float normalDistance = 0.0;
|
||||
#endif
|
||||
float weight = evalBlurCoefficient(blurScales, float(abs(r)), zDistance, normalDistance);
|
||||
|
||||
return vec2(tap.occlusion * weight, weight);
|
||||
}
|
||||
|
||||
vec4 getBlurredOcclusion(ivec2 destPixelCoord, vec2 occlusionTexCoord, vec2 depthTexCoord) {
|
||||
// Stereo side info
|
||||
ivec4 side = getStereoSideInfo(destPixelCoord.x, 0);
|
||||
|
||||
float fragDepth = getZEyeAtUV(depthTexCoord, 0.0);
|
||||
float fragDepthKey = CSZToDepthKey(fragDepth);
|
||||
#if SSAO_BILATERAL_BLUR_USE_NORMAL
|
||||
vec3 fragNormal = getNormalEyeAtUV(depthTexCoord, 0.0);
|
||||
#else
|
||||
vec3 fragNormal = vec3(0.0, 0.0, 1.0);
|
||||
#endif
|
||||
vec2 weightedSums = vec2(0.0);
|
||||
|
||||
// Accumulate weighted contributions along the bluring axis in the [-radius, radius] range
|
||||
int blurRadius = getBlurRadius();
|
||||
vec3 blurScales = getBlurScales();
|
||||
int r;
|
||||
|
||||
// From now on, occlusionTexCoord is the UV pos in the side
|
||||
float sideTexCoord = occlusionTexCoord.x * 2.0 - float(getStereoSide(side)) * getBlurOcclusionUVLimit().x;
|
||||
occlusionTexCoord.x = mix(occlusionTexCoord.x, sideTexCoord, isStereo());
|
||||
|
||||
occlusionTexCoord -= getBlurOcclusionAxis() * float(blurRadius);
|
||||
|
||||
// negative side first
|
||||
for (r = -blurRadius; r <= -1; r++) {
|
||||
weightedSums += evalTapWeightedValue(blurScales, side, r, occlusionTexCoord, fragDepthKey, fragNormal);
|
||||
occlusionTexCoord += getBlurOcclusionAxis();
|
||||
}
|
||||
|
||||
// Central pixel contribution
|
||||
float mainWeight = 1.0;
|
||||
float pixelOcclusion = unpackOcclusion(fetchOcclusionPacked(side, occlusionTexCoord));
|
||||
weightedSums += vec2(pixelOcclusion * mainWeight, mainWeight);
|
||||
occlusionTexCoord += getBlurOcclusionAxis();
|
||||
|
||||
// then positive side
|
||||
for (r = 1; r <= blurRadius; ++r) {
|
||||
weightedSums += evalTapWeightedValue(blurScales, side, r, occlusionTexCoord, fragDepthKey, fragNormal);
|
||||
occlusionTexCoord += getBlurOcclusionAxis();
|
||||
}
|
||||
|
||||
// Final normalization
|
||||
const float epsilon = 0.0001;
|
||||
float result = weightedSums.x / (weightedSums.y + epsilon);
|
||||
|
||||
return packOcclusionOutput(result, fragDepth, fragNormal);
|
||||
}
|
||||
|
||||
layout(location=0) in vec4 varTexCoord0;
|
||||
|
||||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
outFragColor = getBlurredOcclusion(ivec2(gl_FragCoord.xy), varTexCoord0.xy, varTexCoord0.zw);
|
||||
}
|
||||
42
libraries/render-utils/src/ssao_bilateralBlur.slv
Normal file
42
libraries/render-utils/src/ssao_bilateralBlur.slv
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
<@include gpu/Config.slh@>
|
||||
<$VERSION_HEADER$>
|
||||
// Generated on <$_SCRIBE_DATE$>
|
||||
//
|
||||
// ssao_bilateralBlur.vert
|
||||
//
|
||||
// Draw the unit quad [-1,-1 -> 1,1] filling in
|
||||
// Simply draw a Triangle_strip of 2 triangles, no input buffers or index buffer needed
|
||||
//
|
||||
// Created by Olivier Prat on 9/12/2018
|
||||
// Copyright 2018 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 gpu/Transform.slh@>
|
||||
|
||||
<$declareStandardTransform()$>
|
||||
|
||||
layout(location=0) out vec4 varTexCoord0;
|
||||
|
||||
void main(void) {
|
||||
const vec4 UNIT_QUAD[4] = vec4[4](
|
||||
vec4(-1.0, -1.0, 0.0, 1.0),
|
||||
vec4(1.0, -1.0, 0.0, 1.0),
|
||||
vec4(-1.0, 1.0, 0.0, 1.0),
|
||||
vec4(1.0, 1.0, 0.0, 1.0)
|
||||
);
|
||||
vec4 pos = UNIT_QUAD[gl_VertexID];
|
||||
|
||||
// standard transform but applied to the Texcoord
|
||||
vec2 fullTexCoord = (pos.xy + 1.0) * 0.5;
|
||||
vec4 tc = vec4(fullTexCoord, pos.zw);
|
||||
|
||||
TransformObject obj = getTransformObject();
|
||||
<$transformModelToWorldPos(obj, tc, tc)$>
|
||||
|
||||
gl_Position = pos;
|
||||
varTexCoord0.xy = tc.xy;
|
||||
varTexCoord0.zw = fullTexCoord.xy;
|
||||
}
|
||||
42
libraries/render-utils/src/ssao_buildNormals.slf
Normal file
42
libraries/render-utils/src/ssao_buildNormals.slf
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
<@include gpu/Config.slh@>
|
||||
<$VERSION_HEADER$>
|
||||
// Generated on <$_SCRIBE_DATE$>
|
||||
//
|
||||
// ssao_buildNormals.frag
|
||||
//
|
||||
// Created by Olivier Prat on 09/19/18.
|
||||
// Copyright 2018 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 ssao.slh@>
|
||||
<$declareAmbientOcclusion()$>
|
||||
<$declareFetchDepthPyramidMap()$>
|
||||
|
||||
layout(location=0) in vec2 varTexCoord0;
|
||||
|
||||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
// Pixel being shaded
|
||||
vec2 fragCoord = gl_FragCoord.xy;
|
||||
ivec2 fragPixelPos = ivec2(fragCoord.xy);
|
||||
vec2 fragUVPos = varTexCoord0;
|
||||
|
||||
// Stereo side info based on the real viewport size of this pass
|
||||
ivec2 sideNormalsSize = ivec2( getNormalsSideSize() );
|
||||
ivec4 side = getStereoSideInfoFromWidth(fragPixelPos.x, sideNormalsSize.x);
|
||||
|
||||
vec2 deltaDepthUV = vec2(1.0) / getDepthTextureSideSize(0);
|
||||
|
||||
// From now on, fragUVPos is the UV pos in the side
|
||||
fragUVPos = getSideUVFromFramebufferUV(side, fragUVPos);
|
||||
|
||||
// The position and normal of the pixel fragment in Eye space
|
||||
vec3 fragPositionES = buildPosition(side, fragUVPos);
|
||||
vec3 fragNormalES = buildNormal(side, fragUVPos, fragPositionES, deltaDepthUV);
|
||||
|
||||
outFragColor = vec4(packNormal(fragNormalES), 1.0);
|
||||
}
|
||||
|
|
@ -37,96 +37,15 @@ vec2 getDebugCursorTexcoord(){
|
|||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
vec2 imageSize = getSideImageSize(getResolutionLevel());
|
||||
|
||||
// In debug adjust the correct frag pixel based on base resolution
|
||||
vec2 fragCoord = gl_FragCoord.xy;
|
||||
if (getResolutionLevel() > 0) {
|
||||
fragCoord /= float (1 << getResolutionLevel());
|
||||
}
|
||||
|
||||
// Stereo side info based on the real viewport size of this pass
|
||||
vec2 sideDepthSize = getDepthTextureSideSize(0);
|
||||
// Pixel Debugged
|
||||
vec2 cursorUV = getDebugCursorTexcoord();
|
||||
vec2 cursorPixelPos = cursorUV * imageSize;
|
||||
vec2 cursorPixelPos = cursorUV * sideDepthSize;
|
||||
|
||||
ivec2 ssC = ivec2(cursorPixelPos);
|
||||
|
||||
// Fetch the z under the pixel (stereo or not)
|
||||
float Zeye = getZEye(ssC, 0);
|
||||
ivec2 fragUVPos = ivec2(cursorPixelPos);
|
||||
|
||||
// Stereo side info
|
||||
ivec4 side = getStereoSideInfo(ssC.x, getResolutionLevel());
|
||||
// TODO
|
||||
|
||||
// From now on, ssC is the pixel pos in the side
|
||||
ssC.x -= side.y;
|
||||
vec2 fragPos = (vec2(ssC) + vec2(0.5)) / imageSize;
|
||||
|
||||
// The position and normal of the pixel fragment in Eye space
|
||||
vec3 Cp = evalEyePositionFromZeye(side.x, Zeye, fragPos);
|
||||
vec3 Cn = evalEyeNormal(Cp);
|
||||
|
||||
// Choose the screen-space sample radius
|
||||
float ssDiskRadius = evalDiskRadius(Cp.z, imageSize);
|
||||
|
||||
vec2 fragToCursor = cursorPixelPos - fragCoord.xy;
|
||||
if (dot(fragToCursor,fragToCursor) > ssDiskRadius * ssDiskRadius) {
|
||||
discard;
|
||||
}
|
||||
|
||||
// Let's make noise
|
||||
//float randomPatternRotationAngle = getAngleDithering(ssC);
|
||||
vec3 wCp = (getViewInverse() * vec4(Cp, 1.0)).xyz;
|
||||
float randomPatternRotationAngle = getAngleDitheringWorldPos(wCp);
|
||||
|
||||
|
||||
// Accumulate the Obscurance for each samples
|
||||
float sum = 0.0;
|
||||
float keepTapRadius = 1.0;
|
||||
int keepedMip = -1;
|
||||
bool keep = false;
|
||||
int sampleCount = int(getNumSamples());
|
||||
for (int i = 0; i < sampleCount; ++i) {
|
||||
vec3 tap = getTapLocationClamped(i, randomPatternRotationAngle, ssDiskRadius, cursorPixelPos, imageSize);
|
||||
|
||||
// The occluding point in camera space
|
||||
vec2 fragToTap = vec2(ssC) + tap.xy - fragCoord.xy;
|
||||
if (dot(fragToTap,fragToTap) < keepTapRadius) {
|
||||
keep = true;
|
||||
keepedMip = evalMipFromRadius(tap.z * float(doFetchMips()));
|
||||
}
|
||||
|
||||
vec3 tapUVZ = fetchTap(side, ssC, tap, imageSize);
|
||||
|
||||
vec3 Q = evalEyePositionFromZeye(side.x, tapUVZ.z, tapUVZ.xy);
|
||||
|
||||
sum += float(tap.z > 0.0) * evalAO(Cp, Cn, Q);
|
||||
}
|
||||
|
||||
|
||||
float A = max(0.0, 1.0 - sum * getObscuranceScaling() * 5.0 * getInvNumSamples());
|
||||
|
||||
<! // KEEP IT for Debugging
|
||||
// Bilateral box-filter over a quad for free, respecting depth edges
|
||||
// (the difference that this makes is subtle)
|
||||
if (abs(dFdx(Cp.z)) < 0.02) {
|
||||
A -= dFdx(A) * ((ssC.x & 1) - 0.5);
|
||||
}
|
||||
if (abs(dFdy(Cp.z)) < 0.02) {
|
||||
A -= dFdy(A) * ((ssC.y & 1) - 0.5);
|
||||
}
|
||||
!>
|
||||
|
||||
outFragColor = vec4(packOcclusionDepth(A, CSZToDephtKey(Cp.z)), 1.0);
|
||||
|
||||
if ((dot(fragToCursor,fragToCursor) < (100.0 * keepTapRadius * keepTapRadius) )) {
|
||||
// outFragColor = vec4(vec3(A), 1.0);
|
||||
outFragColor = vec4(vec3(A), 1.0);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!keep) {
|
||||
outFragColor = vec4(0.1);
|
||||
} else {
|
||||
outFragColor.rgb = colorWheel(float(keepedMip)/float(MAX_MIP_LEVEL));
|
||||
}
|
||||
outFragColor = packOcclusionOutput(0.0, 0.0, vec3(0.0, 0.0, 1.0));
|
||||
}
|
||||
|
|
|
|||
36
libraries/render-utils/src/ssao_gather.slf
Normal file
36
libraries/render-utils/src/ssao_gather.slf
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
<@include gpu/Config.slh@>
|
||||
<$VERSION_HEADER$>
|
||||
// Generated on <$_SCRIBE_DATE$>
|
||||
//
|
||||
// ssao_gather.frag
|
||||
//
|
||||
// Created by Olivier Prat on 09/19/2018.
|
||||
// Copyright 2018 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 ssao.slh@>
|
||||
|
||||
// Hack comment
|
||||
|
||||
<$declareAmbientOcclusion()$>
|
||||
|
||||
// the source occlusion texture
|
||||
LAYOUT(binding=RENDER_UTILS_TEXTURE_SSAO_OCCLUSION) uniform sampler2DArray occlusionMaps;
|
||||
|
||||
layout(location=0) in vec4 varTexCoord0;
|
||||
|
||||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
// Gather the four splits of the occlusion result back into an interleaved full size
|
||||
// result (at the resolution level, of course)
|
||||
ivec2 destPixelCoord = ivec2(gl_FragCoord.xy);
|
||||
ivec2 sourcePixelCoord = destPixelCoord >> SSAO_SPLIT_LOG2_COUNT;
|
||||
ivec2 modPixelCoord = destPixelCoord & (SSAO_SPLIT_COUNT-1);
|
||||
int occlusionMapIndex = modPixelCoord.x + (modPixelCoord.y << SSAO_SPLIT_LOG2_COUNT);
|
||||
|
||||
outFragColor = texelFetch(occlusionMaps, ivec3(sourcePixelCoord, occlusionMapIndex), 0);
|
||||
}
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
<@include gpu/Config.slh@>
|
||||
<$VERSION_HEADER$>
|
||||
// Generated on <$_SCRIBE_DATE$>
|
||||
//
|
||||
// ssao_makeHorizontalBlur.frag
|
||||
//
|
||||
// Created by Sam Gateau on 1/1/16.
|
||||
// Copyright 2016 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 ssao.slh@>
|
||||
|
||||
const ivec2 horizontal = ivec2(1,0);
|
||||
<$declareBlurPass(horizontal)$>
|
||||
|
||||
|
||||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
outFragColor = vec4(getBlurredOcclusion(gl_FragCoord.xy), 1.0);
|
||||
}
|
||||
|
|
@ -19,71 +19,90 @@
|
|||
|
||||
<$declarePackOcclusionDepth()$>
|
||||
|
||||
#define SSAO_HBAO_MAX_RADIUS 300.0
|
||||
|
||||
layout(location=0) in vec2 varTexCoord0;
|
||||
|
||||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
vec2 imageSize = getSideImageSize(getResolutionLevel());
|
||||
|
||||
// Pixel being shaded
|
||||
vec2 fragCoord = gl_FragCoord.xy;
|
||||
ivec2 ssC = ivec2(fragCoord.xy);
|
||||
ivec2 fragPixelPos = ivec2(fragCoord.xy);
|
||||
vec2 fragUVPos = varTexCoord0;
|
||||
|
||||
// Fetch the z under the pixel (stereo or not)
|
||||
float Zeye = getZEye(ssC, 0);
|
||||
#if SSAO_USE_QUAD_SPLIT
|
||||
vec3 fragNormalES = getNormalEyeAtUV(fragUVPos, 0.0);
|
||||
#endif
|
||||
|
||||
// Stereo side info
|
||||
ivec4 side = getStereoSideInfo(ssC.x, getResolutionLevel());
|
||||
|
||||
// From now on, ssC is the pixel pos in the side
|
||||
ssC.x -= side.y;
|
||||
vec2 fragPos = (vec2(ssC) + vec2(0.5)) / imageSize;
|
||||
|
||||
// The position and normal of the pixel fragment in Eye space
|
||||
vec3 Cp = evalEyePositionFromZeye(side.x, Zeye, fragPos);
|
||||
vec3 Cn = evalEyeNormal(Cp);
|
||||
|
||||
// Choose the screen-space sample radius
|
||||
float ssDiskRadius = evalDiskRadius(Cp.z, imageSize);
|
||||
|
||||
// Let's make noise
|
||||
float randomPatternRotationAngle = getAngleDithering(ssC);
|
||||
//vec3 wCp = (getViewInverse() * vec4(Cp, 1.0)).xyz;
|
||||
//float randomPatternRotationAngle = getAngleDitheringWorldPos(wCp);
|
||||
|
||||
// Accumulate the Obscurance for each samples
|
||||
float sum = 0.0;
|
||||
int sampleCount = int(getNumSamples());
|
||||
for (int i = 0; i < sampleCount; ++i) {
|
||||
vec3 tap = getTapLocationClamped(i, randomPatternRotationAngle, ssDiskRadius, vec2(ssC), imageSize);
|
||||
|
||||
vec3 tapUVZ = fetchTap(side, ssC, tap, imageSize);
|
||||
|
||||
vec3 Q = evalEyePositionFromZeye(side.x, tapUVZ.z, tapUVZ.xy);
|
||||
|
||||
sum += float(tap.z > 0.0) * evalAO(Cp, Cn, Q);
|
||||
// Stereo side info based on the real viewport size of this pass
|
||||
vec2 sideDepthSize = getDepthTextureSideSize(0);
|
||||
ivec2 sideOcclusionSize;
|
||||
if (isHorizonBased()) {
|
||||
sideOcclusionSize = ivec2( getOcclusionSplitSideSize() );
|
||||
} else {
|
||||
sideOcclusionSize = ivec2( getOcclusionSideSize() );
|
||||
}
|
||||
ivec4 side = getStereoSideInfoFromWidth(fragPixelPos.x, sideOcclusionSize.x);
|
||||
// From now on, fragUVPos is the UV pos in the side
|
||||
fragUVPos = getSideUVFromFramebufferUV(side, fragUVPos);
|
||||
fragUVPos = snapToTexel(fragUVPos, sideDepthSize);
|
||||
|
||||
float A = max(0.0, 1.0 - sum * getObscuranceScaling() * 5.0 * getInvNumSamples());
|
||||
// The position and normal of the pixel fragment in Eye space
|
||||
vec2 deltaDepthUV = vec2(2.0) / sideDepthSize;
|
||||
vec3 fragPositionES = buildPosition(side, fragUVPos);
|
||||
#if !SSAO_USE_QUAD_SPLIT
|
||||
vec3 fragNormalES = buildNormal(side, fragUVPos, fragPositionES, deltaDepthUV);
|
||||
#endif
|
||||
|
||||
// KEEP IT for Debugging
|
||||
// Bilateral box-filter over a quad for free, respecting depth edges
|
||||
// (the difference that this makes is subtle)
|
||||
if (abs(dFdx(Cp.z)) < 0.02) {
|
||||
A -= dFdx(A) * (float(ssC.x & 1) - 0.5);
|
||||
float occlusion = 1.0;
|
||||
|
||||
if (fragPositionES.z > (1.0-getPosLinearDepthFar())) {
|
||||
// Choose the screen-space sample radius
|
||||
float diskPixelRadius = evalDiskRadius(fragPositionES.z, sideDepthSize);
|
||||
if (isHorizonBased()) {
|
||||
diskPixelRadius = min(diskPixelRadius, SSAO_HBAO_MAX_RADIUS);
|
||||
}
|
||||
|
||||
// Let's make noise
|
||||
float randomPatternRotationAngle = 0.0;
|
||||
|
||||
// Accumulate the obscurance for each samples
|
||||
float obscuranceSum = 0.0;
|
||||
int numSamples = int(getNumSamples());
|
||||
float invNumSamples = getInvNumSamples();
|
||||
|
||||
if (isHorizonBased()) {
|
||||
randomPatternRotationAngle = getAngleDithering(fragPixelPos);
|
||||
|
||||
for (int i = 0; i < numSamples; ++i) {
|
||||
vec3 deltaTap = getUnitTapLocation(i, 1.0, randomPatternRotationAngle, PI);
|
||||
obscuranceSum += evalVisibilityHBAO(side, fragUVPos, deltaDepthUV, deltaTap.xy, diskPixelRadius, fragPositionES, fragNormalES);
|
||||
}
|
||||
obscuranceSum *= invNumSamples;
|
||||
#if HBAO_USE_COS_ANGLE
|
||||
obscuranceSum = 1.0 - obscuranceSum * getObscuranceScaling();
|
||||
#else
|
||||
obscuranceSum = mix(1.0, obscuranceSum, getObscuranceScaling());
|
||||
#endif
|
||||
} else {
|
||||
// Steps are in the depth texture resolution
|
||||
vec2 depthTexFragPixelPos = fragUVPos * sideDepthSize;
|
||||
|
||||
randomPatternRotationAngle = getAngleDitheringPixelPos(fragPixelPos) + getAngleDitheringSplit();
|
||||
|
||||
for (int i = 0; i < numSamples; ++i) {
|
||||
vec3 tap = getTapLocationClampedSSAO(i, randomPatternRotationAngle, diskPixelRadius, depthTexFragPixelPos, sideDepthSize);
|
||||
vec2 tapUV = fragUVPos + tap.xy * deltaDepthUV;
|
||||
vec2 tapMipZ = fetchTap(side, tapUV, tap.z);
|
||||
vec3 tapPositionES = evalEyePositionFromZeye(side.x, tapMipZ.y, tapUV);
|
||||
obscuranceSum += float(tap.z > 0.0) * evalVisibilitySSAO(fragPositionES, fragNormalES, tapPositionES);
|
||||
}
|
||||
obscuranceSum *= invNumSamples;
|
||||
obscuranceSum = 1.0 - obscuranceSum * getObscuranceScaling();
|
||||
}
|
||||
|
||||
occlusion = clamp(obscuranceSum, 0.0, 1.0);
|
||||
}
|
||||
if (abs(dFdy(Cp.z)) < 0.02) {
|
||||
A -= dFdy(A) * (float(ssC.y & 1) - 0.5);
|
||||
}
|
||||
|
||||
|
||||
outFragColor = vec4(packOcclusionDepth(A, CSZToDephtKey(Cp.z)), 1.0);
|
||||
|
||||
/* {
|
||||
vec3 tap = getTapLocationClamped(2, randomPatternRotationAngle, ssDiskRadius, ssC, imageSize);
|
||||
vec3 tapUVZ = fetchTap(side, ssC, tap, imageSize);
|
||||
vec2 fetchUV = vec2(tapUVZ.x + side.w * 0.5 * (side.x - tapUVZ.x), tapUVZ.y);
|
||||
vec3 Q = evalEyePositionFromZeye(side.x, tapUVZ.z, tapUVZ.xy);
|
||||
outFragColor = vec4(fetchUV, 0.0, 1.0);
|
||||
}*/
|
||||
|
||||
outFragColor = packOcclusionOutput(occlusion, fragPositionES.z, fragNormalES);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,23 +0,0 @@
|
|||
<@include gpu/Config.slh@>
|
||||
<$VERSION_HEADER$>
|
||||
// Generated on <$_SCRIBE_DATE$>
|
||||
//
|
||||
// ssao_makeVerticalBlur.frag
|
||||
//
|
||||
// Created by Sam Gateau on 1/1/16.
|
||||
// Copyright 2016 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 ssao.slh@>
|
||||
|
||||
const ivec2 vertical = ivec2(0,1);
|
||||
<$declareBlurPass(vertical)$>
|
||||
|
||||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
float occlusion = getBlurredOcclusion(gl_FragCoord.xy).x;
|
||||
outFragColor = vec4(occlusion, 0.0, 0.0, occlusion);
|
||||
}
|
||||
28
libraries/render-utils/src/ssao_mip_depth.slf
Normal file
28
libraries/render-utils/src/ssao_mip_depth.slf
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
<@include gpu/Config.slh@>
|
||||
<$VERSION_HEADER$>
|
||||
// Generated on <$_SCRIBE_DATE$>
|
||||
//
|
||||
// ssao_mip_depth.frag
|
||||
// fragment shader
|
||||
//
|
||||
// Created by Olivier Prat on 4/18/18.
|
||||
// Copyright 2018 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 gpu/ShaderConstants.h@>
|
||||
|
||||
LAYOUT(binding=GPU_TEXTURE_MIP_CREATION_INPUT) uniform sampler2D depthTexture;
|
||||
|
||||
layout(location=0) in vec2 varTexCoord0;
|
||||
|
||||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
vec4 depths = textureGather(depthTexture, varTexCoord0);
|
||||
// Keep the minimum depth
|
||||
float outZ = min(depths.w, min(depths.z, min(depths.x, depths.y)));
|
||||
|
||||
outFragColor = vec4(vec3(outZ), 1.0);
|
||||
}
|
||||
64
libraries/render-utils/src/ssao_shared.h
Normal file
64
libraries/render-utils/src/ssao_shared.h
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
// <!
|
||||
// Created by Olivier Prat on 2018/09/18
|
||||
// Copyright 2013-2018 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
|
||||
// !>
|
||||
|
||||
// <@if not RENDER_UTILS_SSAO_SHARED_H@>
|
||||
// <@def RENDER_UTILS_SSAO_SHARED_H@>
|
||||
|
||||
// Hack comment to absorb the extra '//' scribe prepends
|
||||
|
||||
#ifndef RENDER_UTILS_SSAO_SHARED_H
|
||||
#define RENDER_UTILS_SSAO_SHARED_H
|
||||
|
||||
#define SSAO_USE_QUAD_SPLIT 1
|
||||
#define SSAO_BILATERAL_BLUR_USE_NORMAL 0
|
||||
|
||||
#define SSAO_DEPTH_KEY_SCALE 300.0
|
||||
|
||||
#if SSAO_USE_QUAD_SPLIT
|
||||
#define SSAO_SPLIT_LOG2_COUNT 2
|
||||
#else
|
||||
#define SSAO_SPLIT_LOG2_COUNT 0
|
||||
#endif
|
||||
#define SSAO_SPLIT_COUNT (1 << SSAO_SPLIT_LOG2_COUNT)
|
||||
|
||||
// glsl / C++ compatible source as interface for ambient occlusion
|
||||
#ifdef __cplusplus
|
||||
# define SSAO_VEC4 glm::vec4
|
||||
# define SSAO_MAT4 glm::mat4
|
||||
#else
|
||||
# define SSAO_VEC4 vec4
|
||||
# define SSAO_MAT4 mat4
|
||||
#endif
|
||||
|
||||
struct AmbientOcclusionParams {
|
||||
SSAO_VEC4 _resolutionInfo;
|
||||
SSAO_VEC4 _radiusInfo;
|
||||
SSAO_VEC4 _ditheringInfo;
|
||||
SSAO_VEC4 _sampleInfo;
|
||||
SSAO_VEC4 _falloffInfo;
|
||||
SSAO_VEC4 _sideSizes[2];
|
||||
};
|
||||
|
||||
struct AmbientOcclusionFrameParams {
|
||||
SSAO_VEC4 _angleInfo;
|
||||
};
|
||||
|
||||
struct AmbientOcclusionBlurParams {
|
||||
SSAO_VEC4 _blurInfo;
|
||||
SSAO_VEC4 _blurAxis;
|
||||
};
|
||||
|
||||
#endif // RENDER_UTILS_SHADER_CONSTANTS_H
|
||||
|
||||
// <@if 1@>
|
||||
// Trigger Scribe include
|
||||
// <@endif@> <!def that !>
|
||||
|
||||
// <@endif@>
|
||||
|
||||
// Hack Comment
|
||||
|
|
@ -26,9 +26,7 @@ layout(location=1) out vec4 outNormal;
|
|||
void main(void) {
|
||||
// Gather 2 by 2 quads from texture and downsample
|
||||
|
||||
// Try different filters for Z
|
||||
vec4 Zeyes = textureGather(linearDepthMap, varTexCoord0, 0);
|
||||
// float Zeye = texture(linearDepthMap, varTexCoord0).x;
|
||||
|
||||
vec4 rawNormalsX = textureGather(normalMap, varTexCoord0, 0);
|
||||
vec4 rawNormalsY = textureGather(normalMap, varTexCoord0, 1);
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ LAYOUT(binding=0) uniform blurParamsBuffer {
|
|||
BlurParameters parameters;
|
||||
};
|
||||
|
||||
vec2 getViewportInvWidthHeight() {
|
||||
vec2 getInvWidthHeight() {
|
||||
return parameters.resolutionInfo.zw;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,6 +19,6 @@ layout(location=0) in vec2 varTexCoord0;
|
|||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
outFragColor = pixelShaderGaussianDepthAware(varTexCoord0, vec2(1.0, 0.0), getViewportInvWidthHeight());
|
||||
outFragColor = pixelShaderGaussianDepthAware(varTexCoord0, vec2(1.0, 0.0), getInvWidthHeight());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,6 +19,6 @@ layout(location=0) in vec2 varTexCoord0;
|
|||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
outFragColor = pixelShaderGaussianDepthAware(varTexCoord0, vec2(0.0, 1.0), getViewportInvWidthHeight());
|
||||
outFragColor = pixelShaderGaussianDepthAware(varTexCoord0, vec2(0.0, 1.0), getInvWidthHeight());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,6 +20,6 @@ layout(location=0) in vec2 varTexCoord0;
|
|||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
outFragColor = pixelShaderGaussian(varTexCoord0, vec2(1.0, 0.0), getViewportInvWidthHeight());
|
||||
outFragColor = pixelShaderGaussian(varTexCoord0, vec2(1.0, 0.0), getInvWidthHeight());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,6 +19,6 @@ layout(location=0) in vec2 varTexCoord0;
|
|||
layout(location=0) out vec4 outFragColor;
|
||||
|
||||
void main(void) {
|
||||
outFragColor = pixelShaderGaussian(varTexCoord0, vec2(0.0, 1.0), getViewportInvWidthHeight());
|
||||
outFragColor = pixelShaderGaussian(varTexCoord0, vec2(0.0, 1.0), getInvWidthHeight());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,3 +13,4 @@ precision highp float;
|
|||
precision highp samplerBuffer;
|
||||
precision highp sampler2DShadow;
|
||||
precision highp sampler2DArrayShadow;
|
||||
precision lowp sampler2DArray;
|
||||
|
|
|
|||
21
libraries/shared/src/MathUtils.h
Normal file
21
libraries/shared/src/MathUtils.h
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
//
|
||||
// MathUtils.h
|
||||
// libraries/shared/src
|
||||
//
|
||||
// Created by Olivier Prat on 9/21/18.
|
||||
// Copyright 2018 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
|
||||
//
|
||||
|
||||
#ifndef hifi_MathUtils_h
|
||||
#define hifi_MathUtils_h
|
||||
|
||||
template <class T>
|
||||
T divideRoundUp(const T& numerator, int divisor) {
|
||||
return (numerator + divisor - T(1)) / divisor;
|
||||
}
|
||||
|
||||
#endif // hifi_MathUtils_h
|
||||
|
||||
|
|
@ -7,48 +7,60 @@
|
|||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or https://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
import QtQuick 2.5
|
||||
import QtQuick 2.7
|
||||
import QtQuick.Controls 1.4
|
||||
import QtQuick.Layouts 1.3
|
||||
|
||||
import "qrc:///qml/styles-uit"
|
||||
import "qrc:///qml/controls-uit" as HifiControls
|
||||
|
||||
import "configSlider"
|
||||
import "../lib/plotperf"
|
||||
|
||||
Column {
|
||||
spacing: 8
|
||||
Rectangle {
|
||||
HifiConstants { id: hifi;}
|
||||
id: root;
|
||||
anchors.margins: hifi.dimensions.contentMargin.x
|
||||
|
||||
color: hifi.colors.baseGray;
|
||||
|
||||
Column {
|
||||
id: surfaceGeometry
|
||||
spacing: 10
|
||||
spacing: 8
|
||||
anchors.left: parent.left
|
||||
anchors.right: parent.right
|
||||
anchors.margins: hifi.dimensions.contentMargin.x
|
||||
|
||||
Column{
|
||||
Repeater {
|
||||
model: [
|
||||
"Radius:radius:2.0:false",
|
||||
"Level:obscuranceLevel:1.0:false",
|
||||
"Num Taps:numSamples:32:true",
|
||||
"Taps Spiral:numSpiralTurns:10.0:false",
|
||||
"Falloff Bias:falloffBias:0.2:false",
|
||||
"Edge Sharpness:edgeSharpness:1.0:false",
|
||||
"Blur Radius:blurRadius:10.0:false",
|
||||
]
|
||||
ConfigSlider {
|
||||
label: qsTr(modelData.split(":")[0])
|
||||
integral: (modelData.split(":")[3] == 'true')
|
||||
config: Render.getConfig("RenderMainView.AmbientOcclusion")
|
||||
property: modelData.split(":")[1]
|
||||
max: modelData.split(":")[2]
|
||||
min: 0.0
|
||||
}
|
||||
Repeater {
|
||||
model: [
|
||||
"Blur Edge Sharpness:edgeSharpness:1.0:false",
|
||||
"Blur Radius:blurRadius:15.0:true",
|
||||
"Resolution Downscale:resolutionLevel:2:true",
|
||||
]
|
||||
ConfigSlider {
|
||||
label: qsTr(modelData.split(":")[0])
|
||||
integral: (modelData.split(":")[3] == 'true')
|
||||
config: Render.getConfig("RenderMainView.AmbientOcclusion")
|
||||
property: modelData.split(":")[1]
|
||||
max: modelData.split(":")[2]
|
||||
min: 0.0
|
||||
height:38
|
||||
}
|
||||
}
|
||||
Row{
|
||||
|
||||
Row {
|
||||
spacing: 10
|
||||
Column {
|
||||
Repeater {
|
||||
model: [
|
||||
"resolutionLevel:resolutionLevel",
|
||||
"horizonBased:horizonBased",
|
||||
"jitterEnabled:jitterEnabled",
|
||||
"ditheringEnabled:ditheringEnabled",
|
||||
"fetchMipsEnabled:fetchMipsEnabled",
|
||||
"borderingEnabled:borderingEnabled"
|
||||
]
|
||||
CheckBox {
|
||||
HifiControls.CheckBox {
|
||||
boxSize: 20
|
||||
text: qsTr(modelData.split(":")[0])
|
||||
checked: Render.getConfig("RenderMainView.AmbientOcclusion")[modelData.split(":")[1]]
|
||||
onCheckedChanged: { Render.getConfig("RenderMainView.AmbientOcclusion")[modelData.split(":")[1]] = checked }
|
||||
|
|
@ -60,7 +72,8 @@ Column {
|
|||
model: [
|
||||
"debugEnabled:showCursorPixel"
|
||||
]
|
||||
CheckBox {
|
||||
HifiControls.CheckBox {
|
||||
boxSize: 20
|
||||
text: qsTr(modelData.split(":")[0])
|
||||
checked: Render.getConfig("RenderMainView.DebugAmbientOcclusion")[modelData.split(":")[1]]
|
||||
onCheckedChanged: { Render.getConfig("RenderMainView.DebugAmbientOcclusion")[modelData.split(":")[1]] = checked }
|
||||
|
|
@ -84,5 +97,81 @@ Column {
|
|||
}
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
|
||||
TabView {
|
||||
anchors.left: parent.left
|
||||
anchors.right: parent.right
|
||||
height: 400
|
||||
|
||||
Tab {
|
||||
title: "SSAO"
|
||||
|
||||
Rectangle {
|
||||
color: hifi.colors.baseGray;
|
||||
|
||||
Column {
|
||||
spacing: 8
|
||||
anchors.left: parent.left
|
||||
anchors.right: parent.right
|
||||
anchors.margins: hifi.dimensions.contentMargin.x
|
||||
|
||||
Repeater {
|
||||
model: [
|
||||
"Radius:ssaoRadius:2.0:false",
|
||||
"Level:ssaoObscuranceLevel:1.0:false",
|
||||
"Num Taps:ssaoNumSamples:64:true",
|
||||
"Taps Spiral:ssaoNumSpiralTurns:10.0:false",
|
||||
"Falloff Angle:ssaoFalloffAngle:1.0:false",
|
||||
]
|
||||
ConfigSlider {
|
||||
label: qsTr(modelData.split(":")[0])
|
||||
integral: (modelData.split(":")[3] == 'true')
|
||||
config: Render.getConfig("RenderMainView.AmbientOcclusion")
|
||||
property: modelData.split(":")[1]
|
||||
max: modelData.split(":")[2]
|
||||
min: 0.0
|
||||
height:38
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Tab {
|
||||
title: "HBAO"
|
||||
|
||||
Rectangle {
|
||||
color: hifi.colors.baseGray;
|
||||
|
||||
Column {
|
||||
spacing: 8
|
||||
anchors.left: parent.left
|
||||
anchors.right: parent.right
|
||||
anchors.margins: hifi.dimensions.contentMargin.x
|
||||
|
||||
Repeater {
|
||||
model: [
|
||||
"Radius:hbaoRadius:2.0:false",
|
||||
"Level:hbaoObscuranceLevel:1.0:false",
|
||||
"Num Taps:hbaoNumSamples:6:true",
|
||||
"Falloff Angle:hbaoFalloffAngle:1.0:false",
|
||||
]
|
||||
ConfigSlider {
|
||||
label: qsTr(modelData.split(":")[0])
|
||||
integral: (modelData.split(":")[3] == 'true')
|
||||
config: Render.getConfig("RenderMainView.AmbientOcclusion")
|
||||
property: modelData.split(":")[1]
|
||||
max: modelData.split(":")[2]
|
||||
min: 0.0
|
||||
height:38
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,38 +1,99 @@
|
|||
"use strict";
|
||||
|
||||
//
|
||||
// debugSurfaceGeometryPass.js
|
||||
// debugAmbientOcclusionPass.js
|
||||
// tablet-sample-app
|
||||
//
|
||||
// Created by Sam Gateau on 6/6/2016
|
||||
// Copyright 2016 High Fidelity, Inc.
|
||||
// Created by Olivier Prat on April 19 2018.
|
||||
// Copyright 2018 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or https://www.apache.org/licenses/LICENSE-2.0.html
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
// Set up the qml ui
|
||||
var qml = Script.resolvePath('ambientOcclusionPass.qml');
|
||||
var window = new OverlayWindow({
|
||||
title: 'Ambient Occlusion Pass',
|
||||
source: qml,
|
||||
width: 400, height: 300,
|
||||
});
|
||||
window.setPosition(Window.innerWidth - 420, 50 + 550 + 50);
|
||||
window.closed.connect(function() { Script.stop(); });
|
||||
(function() {
|
||||
var TABLET_BUTTON_NAME = "AO";
|
||||
var QMLAPP_URL = Script.resolvePath("./ambientOcclusionPass.qml");
|
||||
|
||||
|
||||
var onLuciScreen = false;
|
||||
|
||||
var moveDebugCursor = false;
|
||||
Controller.mousePressEvent.connect(function (e) {
|
||||
if (e.isMiddleButton) {
|
||||
moveDebugCursor = true;
|
||||
setDebugCursor(e.x, e.y);
|
||||
function onClicked() {
|
||||
if (onLuciScreen) {
|
||||
tablet.gotoHomeScreen();
|
||||
} else {
|
||||
tablet.loadQMLSource(QMLAPP_URL);
|
||||
}
|
||||
}
|
||||
});
|
||||
Controller.mouseReleaseEvent.connect(function() { moveDebugCursor = false; });
|
||||
Controller.mouseMoveEvent.connect(function (e) { if (moveDebugCursor) setDebugCursor(e.x, e.y); });
|
||||
|
||||
var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
|
||||
var button = tablet.addButton({
|
||||
text: TABLET_BUTTON_NAME,
|
||||
sortOrder: 1
|
||||
});
|
||||
|
||||
var hasEventBridge = false;
|
||||
|
||||
function wireEventBridge(on) {
|
||||
if (!tablet) {
|
||||
print("Warning in wireEventBridge(): 'tablet' undefined!");
|
||||
return;
|
||||
}
|
||||
if (on) {
|
||||
if (!hasEventBridge) {
|
||||
tablet.fromQml.connect(fromQml);
|
||||
hasEventBridge = true;
|
||||
}
|
||||
} else {
|
||||
if (hasEventBridge) {
|
||||
tablet.fromQml.disconnect(fromQml);
|
||||
hasEventBridge = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function onScreenChanged(type, url) {
|
||||
if (url === QMLAPP_URL) {
|
||||
onLuciScreen = true;
|
||||
} else {
|
||||
onLuciScreen = false;
|
||||
}
|
||||
|
||||
button.editProperties({isActive: onLuciScreen});
|
||||
wireEventBridge(onLuciScreen);
|
||||
}
|
||||
|
||||
function fromQml(message) {
|
||||
}
|
||||
|
||||
button.clicked.connect(onClicked);
|
||||
tablet.screenChanged.connect(onScreenChanged);
|
||||
|
||||
var moveDebugCursor = false;
|
||||
Controller.mousePressEvent.connect(function (e) {
|
||||
if (e.isMiddleButton) {
|
||||
moveDebugCursor = true;
|
||||
setDebugCursor(e.x, e.y);
|
||||
}
|
||||
});
|
||||
Controller.mouseReleaseEvent.connect(function() { moveDebugCursor = false; });
|
||||
Controller.mouseMoveEvent.connect(function (e) { if (moveDebugCursor) setDebugCursor(e.x, e.y); });
|
||||
|
||||
|
||||
function setDebugCursor(x, y) {
|
||||
nx = (x / Window.innerWidth);
|
||||
ny = 1.0 - ((y) / (Window.innerHeight - 32));
|
||||
Script.scriptEnding.connect(function () {
|
||||
if (onLuciScreen) {
|
||||
tablet.gotoHomeScreen();
|
||||
}
|
||||
button.clicked.disconnect(onClicked);
|
||||
tablet.screenChanged.disconnect(onScreenChanged);
|
||||
tablet.removeButton(button);
|
||||
});
|
||||
|
||||
Render.getConfig("RenderMainView").getConfig("DebugAmbientOcclusion").debugCursorTexcoord = { x: nx, y: ny };
|
||||
}
|
||||
function setDebugCursor(x, y) {
|
||||
nx = ((x + 0.5) / Window.innerWidth);
|
||||
ny = 1.0 - ((y + 0.5) / (Window.innerHeight));
|
||||
|
||||
Render.getConfig("RenderMainView").getConfig("DebugAmbientOcclusion").debugCursorTexcoord = { x: nx, y: ny };
|
||||
}
|
||||
|
||||
}());
|
||||
|
|
|
|||
|
|
@ -204,6 +204,7 @@ Rectangle {
|
|||
ListElement { text: "Debug Scattering"; color: "White" }
|
||||
ListElement { text: "Ambient Occlusion"; color: "White" }
|
||||
ListElement { text: "Ambient Occlusion Blurred"; color: "White" }
|
||||
ListElement { text: "Ambient Occlusion Normal"; color: "White" }
|
||||
ListElement { text: "Velocity"; color: "White" }
|
||||
ListElement { text: "Custom"; color: "White" }
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue