//==============================================================================
Error Fs::init(const ConfigSet&)
{
m_width = m_r->getWidth() / FS_FRACTION;
m_height = m_r->getHeight() / FS_FRACTION;
// Create RT
m_r->createRenderTarget(m_width,
m_height,
Is::RT_PIXEL_FORMAT,
1,
SamplingFilter::NEAREST,
1,
m_rt);
FramebufferInitInfo fbInit;
fbInit.m_colorAttachmentCount = 1;
fbInit.m_colorAttachments[0].m_texture = m_rt;
fbInit.m_colorAttachments[0].m_loadOperation =
AttachmentLoadOperation::CLEAR;
fbInit.m_depthStencilAttachment.m_texture = m_r->getMs().getDepthRt();
fbInit.m_depthStencilAttachment.m_loadOperation =
AttachmentLoadOperation::LOAD;
fbInit.m_depthStencilAttachment.m_mipmap = 1;
m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
// Init the global resources
{
ResourceGroupInitInfo init;
init.m_textures[0].m_texture = m_r->getMs().getDepthRt();
if(m_r->getSmEnabled())
{
init.m_textures[1].m_texture = m_r->getSm().getSpotTextureArray();
init.m_textures[2].m_texture = m_r->getSm().getOmniTextureArray();
}
init.m_uniformBuffers[0].m_uploadedMemory = true;
init.m_uniformBuffers[1].m_uploadedMemory = true;
init.m_uniformBuffers[2].m_uploadedMemory = true;
init.m_storageBuffers[0].m_uploadedMemory = true;
init.m_storageBuffers[1].m_uploadedMemory = true;
m_globalResources = getGrManager().newInstance<ResourceGroup>(init);
}
getGrManager().finish();
return ErrorCode::NONE;
}
Error Dbg::lazyInit()
{
ANKI_ASSERT(!m_initialized);
// RT
m_r->createRenderTarget(m_r->getWidth(),
m_r->getHeight(),
DBG_COLOR_ATTACHMENT_PIXEL_FORMAT,
TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
SamplingFilter::LINEAR,
1,
m_rt);
// Create FB
FramebufferInitInfo fbInit;
fbInit.m_colorAttachmentCount = 1;
fbInit.m_colorAttachments[0].m_texture = m_rt;
fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
fbInit.m_depthStencilAttachment.m_texture = m_r->getMs().m_depthRt;
fbInit.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::LOAD;
fbInit.m_depthStencilAttachment.m_aspect = DepthStencilAspectMask::DEPTH;
m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
m_drawer = getAllocator().newInstance<DebugDrawer>();
ANKI_CHECK(m_drawer->init(m_r));
return ErrorCode::NONE;
}
Error Pps::initInternal(const ConfigSet& config)
{
ANKI_ASSERT("Initializing PPS");
ANKI_CHECK(loadColorGradingTexture("engine_data/DefaultLut.ankitex"));
m_sharpenEnabled = config.getNumber("pps.sharpen");
if(!m_r->getDrawToDefaultFramebuffer())
{
m_r->createRenderTarget(m_r->getWidth(),
m_r->getHeight(),
RT_PIXEL_FORMAT,
TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::SAMPLED_FRAGMENT,
SamplingFilter::LINEAR,
1,
m_rt);
FramebufferInitInfo fbInit;
fbInit.m_colorAttachmentCount = 1;
fbInit.m_colorAttachments[0].m_texture = m_rt;
fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
fbInit.m_colorAttachments[0].m_usageInsideRenderPass = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
}
return ErrorCode::NONE;
}
Error Tiler::initInternal()
{
// Load the program
StringAuto pps(getAllocator());
pps.sprintf("#define TILE_SIZE_X %u\n"
"#define TILE_SIZE_Y %u\n"
"#define TILES_COUNT_X %u\n"
"#define TILES_COUNT_Y %u\n",
TILE_SIZE,
TILE_SIZE,
m_r->getTileCountXY().x(),
m_r->getTileCountXY().y());
ANKI_CHECK(
getResourceManager().loadResourceToCache(m_shader, "shaders/TilerMinMax.comp.glsl", pps.toCString(), "r_"));
PipelineInitInfo pplineInit;
pplineInit.m_shaders[U(ShaderType::COMPUTE)] = m_shader->getGrShader();
m_ppline = getGrManager().newInstance<Pipeline>(pplineInit);
// Allocate the buffers
U pboSize = m_r->getTileCount() * sizeof(Vec2); // The pixel size
for(U i = 0; i < m_outBuffers.getSize(); ++i)
{
// Create the buffer
m_outBuffers[i] =
getGrManager().newInstance<Buffer>(pboSize, BufferUsageBit::STORAGE_ALL, BufferMapAccessBit::READ);
// Create graphics resources
ResourceGroupInitInfo rcinit;
rcinit.m_storageBuffers[0].m_buffer = m_outBuffers[i];
rcinit.m_textures[0].m_texture = m_r->getMs().m_depthRt;
m_rcGroups[i] = getGrManager().newInstance<ResourceGroup>(rcinit);
}
m_currentMinMax.create(getAllocator(), m_r->getTileCount());
return ErrorCode::NONE;
}
Error Is::binLights(RenderingContext& ctx)
{
updateCommonBlock(ctx);
TexturePtr diffDecalTex, normRoughnessDecalTex;
ANKI_CHECK(m_lightBin->bin(*ctx.m_frustumComponent,
getFrameAllocator(),
m_maxLightIds,
true,
ctx.m_is.m_dynBufferInfo.m_uniformBuffers[P_LIGHTS_LOCATION],
ctx.m_is.m_dynBufferInfo.m_uniformBuffers[S_LIGHTS_LOCATION],
&ctx.m_is.m_dynBufferInfo.m_uniformBuffers[PROBES_LOCATION],
ctx.m_is.m_dynBufferInfo.m_uniformBuffers[DECALS_LOCATION],
ctx.m_is.m_dynBufferInfo.m_storageBuffers[CLUSTERS_LOCATION],
ctx.m_is.m_dynBufferInfo.m_storageBuffers[LIGHT_IDS_LOCATION],
diffDecalTex,
normRoughnessDecalTex));
ResourceGroupInitInfo rcinit;
if(diffDecalTex)
{
rcinit.m_textures[0].m_texture = diffDecalTex;
}
else
{
// Bind something because validation layers will complain
rcinit.m_textures[0].m_texture = m_dummyTex;
}
if(normRoughnessDecalTex)
{
rcinit.m_textures[1].m_texture = normRoughnessDecalTex;
}
else
{
rcinit.m_textures[1].m_texture = m_dummyTex;
}
U64 hash = rcinit.computeHash();
if(hash != m_rcGroup1Hash)
{
m_rcGroup1Hash = hash;
m_rcGroup1 = getGrManager().newInstance<ResourceGroup>(rcinit);
}
return ErrorCode::NONE;
}
//==============================================================================
Error BlurringRenderingPass::initBlurring(
Renderer& r, U width, U height, U samples, F32 blurringDistance)
{
Array<StringAuto, 2> pps = {{getAllocator(), getAllocator()}};
pps[1].sprintf(
"#define HPASS\n"
"#define COL_RGB\n"
"#define BLURRING_DIST float(%f)\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES %u\n",
blurringDistance, height, samples);
pps[0].sprintf(
"#define VPASS\n"
"#define COL_RGB\n"
"#define BLURRING_DIST float(%f)\n"
"#define IMG_DIMENSION %u\n"
"#define SAMPLES %u\n",
blurringDistance, width, samples);
for(U i = 0; i < 2; i++)
{
Direction& dir = m_dirs[i];
r.createRenderTarget(width, height,
PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM),
1, SamplingFilter::LINEAR, 1, dir.m_rt);
// Create FB
FramebufferPtr::Initializer fbInit;
fbInit.m_colorAttachmentsCount = 1;
fbInit.m_colorAttachments[0].m_texture = dir.m_rt;
fbInit.m_colorAttachments[0].m_loadOperation =
AttachmentLoadOperation::DONT_CARE;
dir.m_fb.create(&getGrManager(), fbInit);
ANKI_CHECK(dir.m_frag.loadToCache(&getResourceManager(),
"shaders/VariableSamplingBlurGeneric.frag.glsl",
pps[i].toCString(), "r_"));
ANKI_CHECK(r.createDrawQuadPipeline(
dir.m_frag->getGrShader(), dir.m_ppline));
}
return ErrorCode::NONE;
}
void Volumetric::run(RenderingContext& ctx)
{
CommandBufferPtr& cmdb = ctx.m_commandBuffer;
const Frustum& frc = ctx.m_frustumComponent->getFrustum();
// Update uniforms
TransientMemoryInfo dyn = ctx.m_is.m_dynBufferInfo;
Vec4* uniforms = static_cast<Vec4*>(getGrManager().allocateFrameTransientMemory(
sizeof(Vec4) * 2, BufferUsageBit::UNIFORM_ALL, dyn.m_uniformBuffers[3]));
computeLinearizeDepthOptimal(frc.getNear(), frc.getFar(), uniforms[0].x(), uniforms[0].y());
uniforms[1] = Vec4(m_fogColor, m_fogFactor);
// pass 0
cmdb->setViewport(0, 0, m_r->getWidth() / VOLUMETRIC_FRACTION, m_r->getHeight() / VOLUMETRIC_FRACTION);
cmdb->beginRenderPass(m_vblurFb);
cmdb->bindPipeline(m_ppline);
cmdb->bindResourceGroup(m_rc, 0, &dyn);
m_r->drawQuad(cmdb);
cmdb->endRenderPass();
// hpass
cmdb->setTextureSurfaceBarrier(m_rt,
TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
TextureUsageBit::SAMPLED_FRAGMENT,
TextureSurfaceInfo(0, 0, 0, 0));
cmdb->setTextureSurfaceBarrier(
m_tmpRt, TextureUsageBit::NONE, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, TextureSurfaceInfo(0, 0, 0, 0));
cmdb->beginRenderPass(m_hblurFb);
cmdb->bindPipeline(m_hblurPpline);
cmdb->bindResourceGroup(m_hblurRc, 0, nullptr);
m_r->drawQuad(cmdb);
cmdb->endRenderPass();
// vpass
cmdb->setTextureSurfaceBarrier(m_tmpRt,
TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
TextureUsageBit::SAMPLED_FRAGMENT,
TextureSurfaceInfo(0, 0, 0, 0));
cmdb->setTextureSurfaceBarrier(
m_rt, TextureUsageBit::NONE, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, TextureSurfaceInfo(0, 0, 0, 0));
cmdb->beginRenderPass(m_vblurFb);
cmdb->bindPipeline(m_vblurPpline);
cmdb->bindResourceGroup(m_vblurRc, 0, nullptr);
m_r->drawQuad(cmdb);
cmdb->endRenderPass();
}
void Is::updateCommonBlock(RenderingContext& ctx)
{
const FrustumComponent& fr = *ctx.m_frustumComponent;
ShaderCommonUniforms* blk =
static_cast<ShaderCommonUniforms*>(getGrManager().allocateFrameTransientMemory(sizeof(ShaderCommonUniforms),
BufferUsageBit::UNIFORM_ALL,
ctx.m_is.m_dynBufferInfo.m_uniformBuffers[COMMON_VARS_LOCATION]));
// Start writing
blk->m_projectionParams = fr.getProjectionParameters();
blk->m_viewMat = fr.getViewMatrix().getTransposed();
blk->m_nearFarClustererMagicPad1 = Vec4(
fr.getFrustum().getNear(), fr.getFrustum().getFar(), m_lightBin->getClusterer().getShaderMagicValue(), 0.0);
blk->m_invViewRotation = Mat3x4(fr.getViewMatrix().getInverse().getRotationPart());
blk->m_rendererSizeTimePad1 = Vec4(m_r->getWidth(), m_r->getHeight(), HighRezTimer::getCurrentTime(), 0.0);
blk->m_tileCount = UVec4(m_r->getTileCountXY(), m_lightBin->getClusterer().getClusterCountZ(), m_r->getTileCount());
}
//==============================================================================
void Volumetric::run(RenderingContext& ctx)
{
const Frustum& frc = ctx.m_frustumComponent->getFrustum();
CommandBufferPtr& cmdb = ctx.m_commandBuffer;
// Update uniforms
TransientMemoryInfo dyn;
Vec4* uniforms = static_cast<Vec4*>(
getGrManager().allocateFrameTransientMemory(sizeof(Vec4) * 2,
BufferUsageBit::UNIFORM_ANY_SHADER,
dyn.m_uniformBuffers[0]));
computeLinearizeDepthOptimal(
frc.getNear(), frc.getFar(), uniforms[0].x(), uniforms[0].y());
uniforms[1] = Vec4(m_fogColor, m_fogFactor);
// Draw
cmdb->bindPipeline(m_ppline);
cmdb->bindResourceGroup(m_rcGroup, 0, &dyn);
m_r->drawQuad(cmdb);
}
//==============================================================================
Error Volumetric::init(const ConfigSet& config)
{
// Create frag shader
ANKI_CHECK(getResourceManager().loadResource(
"shaders/Volumetric.frag.glsl", m_frag));
// Create ppline
ColorStateInfo colorState;
colorState.m_attachmentCount = 1;
colorState.m_attachments[0].m_srcBlendMethod = BlendMethod::ONE;
colorState.m_attachments[0].m_dstBlendMethod = BlendMethod::ONE;
m_r->createDrawQuadPipeline(m_frag->getGrShader(), colorState, m_ppline);
// Create the resource group
ResourceGroupInitInfo rcInit;
rcInit.m_textures[0].m_texture = m_r->getMs().getDepthRt();
rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
m_rcGroup = getGrManager().newInstance<ResourceGroup>(rcInit);
return ErrorCode::NONE;
}
Error Pps::run(RenderingContext& ctx)
{
CommandBufferPtr& cmdb = ctx.m_commandBuffer;
// Get the drawing parameters
Bool drawToDefaultFb = ctx.m_outFb.isCreated();
Bool dbgEnabled = m_r->getDbg().getEnabled();
// Get or create the ppline
PipelinePtr& ppline = m_ppline[drawToDefaultFb][dbgEnabled];
if(!ppline)
{
// Need to create it
ShaderResourcePtr& frag = m_frag[drawToDefaultFb][dbgEnabled];
if(!frag)
{
StringAuto pps(ctx.m_tempAllocator);
pps.sprintf("#define BLOOM_ENABLED %u\n"
"#define SHARPEN_ENABLED %u\n"
"#define FBO_WIDTH %u\n"
"#define FBO_HEIGHT %u\n"
"#define LUT_SIZE %u.0\n"
"#define DBG_ENABLED %u\n"
"#define DRAW_TO_DEFAULT %u\n"
"#define SMAA_ENABLED 1\n"
"#define SMAA_RT_METRICS vec4(%f, %f, %f, %f)\n"
"#define SMAA_PRESET_%s\n",
true,
m_sharpenEnabled,
m_r->getWidth(),
m_r->getHeight(),
LUT_SIZE,
dbgEnabled,
drawToDefaultFb,
1.0 / m_r->getWidth(),
1.0 / m_r->getHeight(),
F32(m_r->getWidth()),
F32(m_r->getHeight()),
&m_r->getSmaa().m_qualityPerset[0]);
ANKI_CHECK(getResourceManager().loadResourceToCache(frag, "shaders/Pps.frag.glsl", pps.toCString(), "r_"));
}
if(!m_vert)
{
StringAuto pps(ctx.m_tempAllocator);
pps.sprintf("#define SMAA_ENABLED 1\n"
"#define SMAA_RT_METRICS vec4(%f, %f, %f, %f)\n"
"#define SMAA_PRESET_%s\n",
1.0 / m_r->getWidth(),
1.0 / m_r->getHeight(),
F32(m_r->getWidth()),
F32(m_r->getHeight()),
&m_r->getSmaa().m_qualityPerset[0]);
ANKI_CHECK(
getResourceManager().loadResourceToCache(m_vert, "shaders/Pps.vert.glsl", pps.toCString(), "r_"));
}
PixelFormat pfs = (drawToDefaultFb) ? PixelFormat(ComponentFormat::DEFAULT_FRAMEBUFFER, TransformFormat::NONE)
: RT_PIXEL_FORMAT;
PipelineInitInfo ppinit;
ppinit.m_inputAssembler.m_topology = PrimitiveTopology::TRIANGLE_STRIP;
ppinit.m_depthStencil.m_depthWriteEnabled = false;
ppinit.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
ppinit.m_color.m_attachmentCount = 1;
ppinit.m_color.m_attachments[0].m_format = pfs;
ppinit.m_shaders[ShaderType::VERTEX] = m_vert->getGrShader();
ppinit.m_shaders[ShaderType::FRAGMENT] = frag->getGrShader();
ppline = m_r->getGrManager().newInstance<Pipeline>(ppinit);
}
// Get or create the resource group
ResourceGroupPtr& rsrc = m_rcGroup[dbgEnabled];
if(!rsrc || m_lutDirty)
{
ResourceGroupInitInfo rcInit;
rcInit.m_textures[0].m_texture = m_r->getIs().getRt();
rcInit.m_textures[1].m_texture = m_r->getBloom().m_upscale.m_rt;
rcInit.m_textures[2].m_texture = m_lut->getGrTexture();
rcInit.m_textures[3].m_texture = m_r->getSmaa().m_weights.m_rt;
if(dbgEnabled)
{
rcInit.m_textures[4].m_texture = m_r->getDbg().getRt();
}
rcInit.m_storageBuffers[0].m_buffer = m_r->getTm().getAverageLuminanceBuffer();
rcInit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ;
rsrc = getGrManager().newInstance<ResourceGroup>(rcInit);
m_lutDirty = false;
}
// Get or create FB
FramebufferPtr* fb = nullptr;
U width, height;
if(drawToDefaultFb)
{
fb = &ctx.m_outFb;
width = ctx.m_outFbWidth;
height = ctx.m_outFbHeight;
}
else
{
width = m_r->getWidth();
height = m_r->getHeight();
fb = &m_fb;
}
cmdb->beginRenderPass(*fb);
cmdb->setViewport(0, 0, width, height);
cmdb->bindPipeline(ppline);
cmdb->bindResourceGroup(rsrc, 0, nullptr);
m_r->drawQuad(cmdb);
cmdb->endRenderPass();
if(!drawToDefaultFb)
{
cmdb->setTextureSurfaceBarrier(m_rt,
TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
TextureUsageBit::SAMPLED_FRAGMENT,
TextureSurfaceInfo(0, 0, 0, 0));
}
return ErrorCode::NONE;
}
Error Volumetric::init(const ConfigSet& config)
{
U width = m_r->getWidth() / VOLUMETRIC_FRACTION;
U height = m_r->getHeight() / VOLUMETRIC_FRACTION;
// Create RTs
m_r->createRenderTarget(width,
height,
IS_COLOR_ATTACHMENT_PIXEL_FORMAT,
TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
SamplingFilter::LINEAR,
1,
m_rt);
m_r->createRenderTarget(width,
height,
IS_COLOR_ATTACHMENT_PIXEL_FORMAT,
TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::CLEAR,
SamplingFilter::LINEAR,
1,
m_tmpRt);
m_r->clearRenderTarget(m_tmpRt, ClearValue(), TextureUsageBit::SAMPLED_FRAGMENT);
// Create shaders
ANKI_CHECK(m_r->createShader("shaders/Volumetric.frag.glsl",
m_frag,
"#define RPASS_SIZE uvec2(%uu, %uu)\n"
"#define CLUSTER_COUNT uvec3(%uu, %uu, %uu)\n",
width,
height,
m_r->getIs().getLightBin().getClusterer().getClusterCountX(),
m_r->getIs().getLightBin().getClusterer().getClusterCountY(),
m_r->getIs().getLightBin().getClusterer().getClusterCountZ()));
ANKI_CHECK(m_r->createShader("shaders/GaussianBlurGeneric.frag.glsl",
m_hblurFrag,
"#define HPASS\n"
"#define COL_RGB\n"
"#define TEXTURE_SIZE vec2(%f, %f)\n"
"#define KERNEL_SIZE 11\n",
F32(width),
F32(height)));
ANKI_CHECK(m_r->createShader("shaders/GaussianBlurGeneric.frag.glsl",
m_vblurFrag,
"#define VPASS\n"
"#define COL_RGB\n"
"#define TEXTURE_SIZE vec2(%f, %f)\n"
"#define KERNEL_SIZE 11\n",
F32(width),
F32(height)));
// Create pplines
ColorStateInfo state;
state.m_attachmentCount = 1;
state.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
m_r->createDrawQuadPipeline(m_frag->getGrShader(), state, m_ppline);
m_r->createDrawQuadPipeline(m_hblurFrag->getGrShader(), state, m_hblurPpline);
m_r->createDrawQuadPipeline(m_vblurFrag->getGrShader(), state, m_vblurPpline);
// Create the resource groups
ResourceGroupInitInfo rcInit;
rcInit.m_textures[0].m_texture = m_r->getHalfDepth().m_depthRt;
rcInit.m_textures[0].m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
rcInit.m_textures[1].m_texture = m_tmpRt;
rcInit.m_textures[2].m_texture = m_r->getSm().getSpotTextureArray();
rcInit.m_textures[3].m_texture = m_r->getSm().getOmniTextureArray();
rcInit.m_uniformBuffers[0].m_uploadedMemory = true;
rcInit.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_uniformBuffers[1].m_uploadedMemory = true;
rcInit.m_uniformBuffers[1].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_uniformBuffers[2].m_uploadedMemory = true;
rcInit.m_uniformBuffers[2].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_uniformBuffers[3].m_uploadedMemory = true;
rcInit.m_uniformBuffers[3].m_usage = BufferUsageBit::UNIFORM_FRAGMENT;
rcInit.m_storageBuffers[0].m_uploadedMemory = true;
rcInit.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ;
rcInit.m_storageBuffers[1].m_uploadedMemory = true;
rcInit.m_storageBuffers[1].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ;
m_rc = getGrManager().newInstance<ResourceGroup>(rcInit);
rcInit = ResourceGroupInitInfo();
rcInit.m_textures[0].m_texture = m_rt;
m_hblurRc = getGrManager().newInstance<ResourceGroup>(rcInit);
rcInit.m_textures[0].m_texture = m_tmpRt;
m_vblurRc = getGrManager().newInstance<ResourceGroup>(rcInit);
// Create FBs
FramebufferInitInfo fbInit;
fbInit.m_colorAttachmentCount = 1;
fbInit.m_colorAttachments[0].m_texture = m_tmpRt;
fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
fbInit.m_colorAttachments[0].m_usageInsideRenderPass = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
m_hblurFb = getGrManager().newInstance<Framebuffer>(fbInit);
fbInit.m_colorAttachments[0].m_texture = m_rt;
m_vblurFb = getGrManager().newInstance<Framebuffer>(fbInit);
return ErrorCode::NONE;
}
Error Is::initInternal(const ConfigSet& config)
{
m_maxLightIds = config.getNumber("is.maxLightsPerCluster");
if(m_maxLightIds == 0)
{
ANKI_LOGE("Incorrect number of max light indices");
return ErrorCode::USER_DATA;
}
m_rtMipCount = computeMaxMipmapCount2d(m_r->getWidth(), m_r->getHeight(), 32);
ANKI_ASSERT(m_rtMipCount);
U clusterCount = m_r->getTileCountXY().x() * m_r->getTileCountXY().y() * config.getNumber("clusterSizeZ");
m_clusterCount = clusterCount;
m_maxLightIds *= clusterCount;
m_lightBin = getAllocator().newInstance<LightBin>(getAllocator(),
m_r->getTileCountXY().x(),
m_r->getTileCountXY().y(),
config.getNumber("clusterSizeZ"),
&m_r->getThreadPool(),
&getGrManager());
//
// Load the programs
//
StringAuto pps(getAllocator());
pps.sprintf("\n#define TILE_COUNT_X %u\n"
"#define TILE_COUNT_Y %u\n"
"#define CLUSTER_COUNT %u\n"
"#define RENDERER_WIDTH %u\n"
"#define RENDERER_HEIGHT %u\n"
"#define MAX_LIGHT_INDICES %u\n"
"#define POISSON %u\n"
"#define INDIRECT_ENABLED %u\n"
"#define IR_MIPMAP_COUNT %u\n",
m_r->getTileCountXY().x(),
m_r->getTileCountXY().y(),
clusterCount,
m_r->getWidth(),
m_r->getHeight(),
m_maxLightIds,
m_r->getSm().getPoissonEnabled(),
1,
m_r->getIr().getReflectionTextureMipmapCount());
// point light
ANKI_CHECK(getResourceManager().loadResourceToCache(m_lightVert, "shaders/Is.vert.glsl", pps.toCString(), "r_"));
ANKI_CHECK(getResourceManager().loadResourceToCache(m_lightFrag, "shaders/Is.frag.glsl", pps.toCString(), "r_"));
PipelineInitInfo init;
init.m_inputAssembler.m_topology = PrimitiveTopology::TRIANGLE_STRIP;
init.m_depthStencil.m_depthWriteEnabled = false;
init.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
init.m_color.m_attachmentCount = 1;
init.m_color.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
init.m_shaders[U(ShaderType::VERTEX)] = m_lightVert->getGrShader();
init.m_shaders[U(ShaderType::FRAGMENT)] = m_lightFrag->getGrShader();
m_lightPpline = getGrManager().newInstance<Pipeline>(init);
//
// Create framebuffer
//
m_r->createRenderTarget(m_r->getWidth(),
m_r->getHeight(),
IS_COLOR_ATTACHMENT_PIXEL_FORMAT,
TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE
| TextureUsageBit::SAMPLED_COMPUTE,
SamplingFilter::LINEAR,
m_rtMipCount,
m_rt);
FramebufferInitInfo fbInit;
fbInit.m_colorAttachmentCount = 1;
fbInit.m_colorAttachments[0].m_texture = m_rt;
fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
fbInit.m_colorAttachments[0].m_usageInsideRenderPass = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
//
// Create resource group
//
{
ResourceGroupInitInfo init;
init.m_textures[0].m_texture = m_r->getMs().m_rt0;
init.m_textures[1].m_texture = m_r->getMs().m_rt1;
init.m_textures[2].m_texture = m_r->getMs().m_rt2;
init.m_textures[3].m_texture = m_r->getMs().m_depthRt;
init.m_textures[3].m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ;
init.m_textures[4].m_texture = m_r->getSm().getSpotTextureArray();
init.m_textures[5].m_texture = m_r->getSm().getOmniTextureArray();
init.m_textures[6].m_texture = m_r->getIr().getReflectionTexture();
init.m_textures[7].m_texture = m_r->getIr().getIrradianceTexture();
init.m_textures[8].m_texture = m_r->getIr().getIntegrationLut();
init.m_textures[8].m_sampler = m_r->getIr().getIntegrationLutSampler();
init.m_uniformBuffers[0].m_uploadedMemory = true;
init.m_uniformBuffers[0].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
init.m_uniformBuffers[1].m_uploadedMemory = true;
init.m_uniformBuffers[1].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
init.m_uniformBuffers[2].m_uploadedMemory = true;
init.m_uniformBuffers[2].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
init.m_uniformBuffers[3].m_uploadedMemory = true;
init.m_uniformBuffers[3].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
init.m_uniformBuffers[4].m_uploadedMemory = true;
init.m_uniformBuffers[4].m_usage = BufferUsageBit::UNIFORM_FRAGMENT | BufferUsageBit::UNIFORM_VERTEX;
init.m_storageBuffers[0].m_uploadedMemory = true;
init.m_storageBuffers[0].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ | BufferUsageBit::STORAGE_VERTEX_READ;
init.m_storageBuffers[1].m_uploadedMemory = true;
init.m_storageBuffers[1].m_usage = BufferUsageBit::STORAGE_FRAGMENT_READ | BufferUsageBit::STORAGE_VERTEX_READ;
m_rcGroup = getGrManager().newInstance<ResourceGroup>(init);
}
TextureInitInfo texinit;
texinit.m_width = texinit.m_height = 4;
texinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT;
texinit.m_format = PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM);
m_dummyTex = getGrManager().newInstance<Texture>(texinit);
return ErrorCode::NONE;
}
Error Is::getOrCreatePipeline(ShaderVariantBit variantMask, RenderingContext& ctx, PipelinePtr& ppline)
{
auto it = m_shaderVariantMap.find(variantMask);
if(it != m_shaderVariantMap.getEnd())
{
ppline = it->m_lightPpline;
}
else
{
StringAuto pps(ctx.m_tempAllocator);
pps.sprintf("#define TILE_COUNT_X %u\n"
"#define TILE_COUNT_Y %u\n"
"#define CLUSTER_COUNT %u\n"
"#define RENDERER_WIDTH %u\n"
"#define RENDERER_HEIGHT %u\n"
"#define MAX_LIGHT_INDICES %u\n"
"#define POISSON %u\n"
"#define INDIRECT_ENABLED %u\n"
"#define IR_MIPMAP_COUNT %u\n"
"#define POINT_LIGHTS_ENABLED %u\n"
"#define SPOT_LIGHTS_ENABLED %u\n"
"#define DECALS_ENABLED %u\n"
"#define POINT_LIGHTS_SHADOWS_ENABLED %u\n"
"#define SPOT_LIGHTS_SHADOWS_ENABLED %u\n",
m_r->getTileCountXY().x(),
m_r->getTileCountXY().y(),
m_clusterCount,
m_r->getWidth(),
m_r->getHeight(),
m_maxLightIds,
m_r->getSm().getPoissonEnabled(),
!!(variantMask & ShaderVariantBit::INDIRECT),
m_r->getIr().getReflectionTextureMipmapCount(),
!!(variantMask & ShaderVariantBit::P_LIGHTS),
!!(variantMask & ShaderVariantBit::S_LIGHTS),
!!(variantMask & ShaderVariantBit::DECALS),
!!(variantMask & ShaderVariantBit::P_LIGHTS_SHADOWS),
!!(variantMask & ShaderVariantBit::S_LIGHTS_SHADOWS));
ShaderVariant variant;
ANKI_CHECK(getResourceManager().loadResourceToCache(
variant.m_lightFrag, "shaders/Is.frag.glsl", pps.toCString(), "r_"));
PipelineInitInfo init;
init.m_inputAssembler.m_topology = PrimitiveTopology::TRIANGLE_STRIP;
init.m_depthStencil.m_depthWriteEnabled = false;
init.m_depthStencil.m_depthCompareFunction = CompareOperation::ALWAYS;
init.m_color.m_attachmentCount = 1;
init.m_color.m_attachments[0].m_format = IS_COLOR_ATTACHMENT_PIXEL_FORMAT;
init.m_shaders[U(ShaderType::VERTEX)] = m_lightVert->getGrShader();
init.m_shaders[U(ShaderType::FRAGMENT)] = m_lightFrag->getGrShader();
variant.m_lightPpline = getGrManager().newInstance<Pipeline>(init);
ppline = variant.m_lightPpline;
m_shaderVariantMap.pushBack(getAllocator(), variantMask, variant);
}
return ErrorCode::NONE;
}
