//==============================================================================
void Hdr::initFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
{
GlDevice& gl = getGlDevice();
m_r->createRenderTarget(m_width, m_height, GL_RGB8, GL_RGB,
GL_UNSIGNED_BYTE, 1, rt);
// Set to bilinear because the blurring techniques take advantage of that
GlCommandBufferHandle jobs(&gl);
rt.setFilter(jobs, GlTextureHandle::Filter::LINEAR);
// Create FB
fb = GlFramebufferHandle(jobs, {{rt, GL_COLOR_ATTACHMENT0}});
jobs.finish();
}
//==============================================================================
void Pps::initInternal(const ConfigSet& config)
{
m_enabled = config.get("pps.enabled");
if(!m_enabled)
{
return;
}
ANKI_ASSERT("Initializing PPS");
m_ssao.init(config);
m_hdr.init(config);
m_lf.init(config);
m_sslr.init(config);
// FBO
GlCommandBufferHandle cmdBuff;
cmdBuff.create(&getGlDevice());
m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(), GL_RGB8, GL_RGB,
GL_UNSIGNED_BYTE, 1, m_rt);
m_fb.create(cmdBuff, {{m_rt, GL_COLOR_ATTACHMENT0}});
// SProg
String pps(getAllocator());
pps.sprintf(
"#define SSAO_ENABLED %u\n"
"#define HDR_ENABLED %u\n"
"#define SHARPEN_ENABLED %u\n"
"#define GAMMA_CORRECTION_ENABLED %u\n"
"#define FBO_WIDTH %u\n"
"#define FBO_HEIGHT %u\n",
m_ssao.getEnabled(),
m_hdr.getEnabled(),
static_cast<U>(config.get("pps.sharpen")),
static_cast<U>(config.get("pps.gammaCorrection")),
m_r->getWidth(),
m_r->getHeight());
m_frag.loadToCache(&getResourceManager(),
"shaders/Pps.frag.glsl", pps.toCString(), "r_");
m_ppline = m_r->createDrawQuadProgramPipeline(m_frag->getGlProgram());
cmdBuff.finish();
}
//==============================================================================
void Hdr::initInternal(const ConfigSet& initializer)
{
m_enabled = initializer.get("pps.hdr.enabled");
if(!m_enabled)
{
return;
}
const F32 renderingQuality = initializer.get("pps.hdr.renderingQuality");
m_width = renderingQuality * (F32)m_r->getWidth();
alignRoundDown(16, m_width);
m_height = renderingQuality * (F32)m_r->getHeight();
alignRoundDown(16, m_height);
m_exposure = initializer.get("pps.hdr.exposure");
m_blurringDist = initializer.get("pps.hdr.blurringDist");
m_blurringIterationsCount =
initializer.get("pps.hdr.blurringIterationsCount");
initFb(m_hblurFb, m_hblurRt);
initFb(m_vblurFb, m_vblurRt);
// init shaders
GlDevice& gl = getGlDevice();
GlCommandBufferHandle jobs(&gl);
m_commonBuff = GlBufferHandle(jobs, GL_SHADER_STORAGE_BUFFER,
sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT);
updateDefaultBlock(jobs);
jobs.flush();
m_toneFrag.load("shaders/PpsHdr.frag.glsl", &getResourceManager());
m_tonePpline =
m_r->createDrawQuadProgramPipeline(m_toneFrag->getGlProgram());
const char* SHADER_FILENAME =
"shaders/VariableSamplingBlurGeneric.frag.glsl";
String pps(getAllocator());
pps.sprintf("#define HPASS\n"
"#define COL_RGB\n"
"#define BLURRING_DIST float(%f)\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES %u\n",
m_blurringDist, m_height,
static_cast<U>(initializer.get("pps.hdr.samples")));
m_hblurFrag.load(ProgramResource::createSourceToCache(
SHADER_FILENAME, pps.toCString(), "r_",
getResourceManager()).toCString(),
&getResourceManager());
m_hblurPpline =
m_r->createDrawQuadProgramPipeline(m_hblurFrag->getGlProgram());
pps.sprintf("#define VPASS\n"
"#define COL_RGB\n"
"#define BLURRING_DIST float(%f)\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES %u\n",
m_blurringDist, m_width,
static_cast<U>(initializer.get("pps.hdr.samples")));
m_vblurFrag.load(ProgramResource::createSourceToCache(
SHADER_FILENAME, pps.toCString(), "r_",
getResourceManager()).toCString(),
&getResourceManager());
m_vblurPpline =
m_r->createDrawQuadProgramPipeline(m_vblurFrag->getGlProgram());
// Set timestamps
m_parameterUpdateTimestamp = getGlobTimestamp();
m_commonUboUpdateTimestamp = getGlobTimestamp();
}
//==============================================================================
void Ssao::initInternal(const ConfigSet& config)
{
m_enabled = config.get("pps.ssao.enabled");
if(!m_enabled)
{
return;
}
m_blurringIterationsCount =
config.get("pps.ssao.blurringIterationsCount");
//
// Init the widths/heights
//
const F32 quality = config.get("pps.ssao.renderingQuality");
m_width = quality * (F32)m_r->getWidth();
alignRoundUp(16, m_width);
m_height = quality * (F32)m_r->getHeight();
alignRoundUp(16, m_height);
//
// create FBOs
//
createFb(m_hblurFb, m_hblurRt);
createFb(m_vblurFb, m_vblurRt);
//
// noise texture
//
GlCommandBufferHandle cmdb;
cmdb.create(&getGlDevice());
GlClientBufferHandle noise;
noise.create(
cmdb, sizeof(Vec3) * NOISE_TEX_SIZE * NOISE_TEX_SIZE, nullptr);
genNoise((Vec3*)noise.getBaseAddress(),
(Vec3*)((U8*)noise.getBaseAddress() + noise.getSize()));
GlTextureHandle::Initializer tinit;
tinit.m_width = tinit.m_height = NOISE_TEX_SIZE;
tinit.m_target = GL_TEXTURE_2D;
tinit.m_internalFormat = GL_RGB32F;
tinit.m_format = GL_RGB;
tinit.m_type = GL_FLOAT;
tinit.m_filterType = GlTextureHandle::Filter::NEAREST;
tinit.m_repeat = true;
tinit.m_mipmapsCount = 1;
tinit.m_data[0][0] = noise;
m_noiseTex.create(cmdb, tinit);
//
// Kernel
//
String kernelStr(getAllocator());
Array<Vec3, KERNEL_SIZE> kernel;
genKernel(kernel.begin(), kernel.end());
kernelStr = "vec3[](";
for(U i = 0; i < kernel.size(); i++)
{
String tmp(getAllocator());
tmp.sprintf("vec3(%f, %f, %f) %s",
kernel[i].x(), kernel[i].y(), kernel[i].z(),
(i != kernel.size() - 1) ? ", " : ")");
kernelStr += tmp;
}
//
// Shaders
//
m_uniformsBuff.create(cmdb, GL_SHADER_STORAGE_BUFFER,
sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT);
String pps(getAllocator());
// main pass prog
pps.sprintf(
"#define NOISE_MAP_SIZE %u\n"
"#define WIDTH %u\n"
"#define HEIGHT %u\n"
"#define KERNEL_SIZE %u\n"
"#define KERNEL_ARRAY %s\n",
NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]);
m_ssaoFrag.loadToCache(&getResourceManager(),
"shaders/PpsSsao.frag.glsl", pps.toCString(), "r_");
m_ssaoPpline = m_r->createDrawQuadProgramPipeline(
m_ssaoFrag->getGlProgram());
// blurring progs
const char* SHADER_FILENAME =
"shaders/VariableSamplingBlurGeneric.frag.glsl";
pps.sprintf(
"#define HPASS\n"
"#define COL_R\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES 7\n",
m_height);
m_hblurFrag.loadToCache(&getResourceManager(),
SHADER_FILENAME, pps.toCString(), "r_");
m_hblurPpline = m_r->createDrawQuadProgramPipeline(
m_hblurFrag->getGlProgram());
pps.sprintf(
"#define VPASS\n"
"#define COL_R\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES 7\n",
m_width);
m_vblurFrag.loadToCache(&getResourceManager(),
SHADER_FILENAME, pps.toCString(), "r_");
m_vblurPpline = m_r->createDrawQuadProgramPipeline(
m_vblurFrag->getGlProgram());
cmdb.flush();
}
