Error ShadowMapping::initScratch(const ConfigSet& cfg)
{
// Init the shadowmaps and FBs
{
m_scratchTileCountX = cfg.getNumber("r.shadowMapping.scratchTileCountX");
m_scratchTileCountY = cfg.getNumber("r.shadowMapping.scratchTileCountY");
m_scratchTileResolution = cfg.getNumber("r.shadowMapping.tileResolution");
// RT
m_scratchRtDescr = m_r->create2DRenderTargetDescription(m_scratchTileResolution * m_scratchTileCountX,
m_scratchTileResolution * m_scratchTileCountY,
SHADOW_DEPTH_PIXEL_FORMAT,
"Scratch ShadMap");
m_scratchRtDescr.bake();
// FB
m_scratchFbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::CLEAR;
m_scratchFbDescr.m_depthStencilAttachment.m_clearValue.m_depthStencil.m_depth = 1.0f;
m_scratchFbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
m_scratchFbDescr.bake();
}
m_scratchTileAlloc.init(getAllocator(), m_scratchTileCountX, m_scratchTileCountY, m_lodCount, false);
return Error::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 FinalComposite::initInternal(const ConfigSet& config)
{
ANKI_ASSERT("Initializing PPS");
ANKI_CHECK(loadColorGradingTexture("engine_data/DefaultLut.ankitex"));
m_fbDescr.m_colorAttachmentCount = 1;
m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
m_fbDescr.bake();
ANKI_CHECK(getResourceManager().loadResource("engine_data/BlueNoiseLdrRgb64x64.ankitex", m_blueNoise));
// Progs
ANKI_CHECK(getResourceManager().loadResource("shaders/FinalComposite.glslp", m_prog));
ShaderProgramResourceMutationInitList<3> mutations(m_prog);
mutations.add("BLUE_NOISE", 1).add("BLOOM_ENABLED", 1).add("DBG_ENABLED", 0);
ShaderProgramResourceConstantValueInitList<3> consts(m_prog);
consts.add("LUT_SIZE", U32(LUT_SIZE))
.add("FB_SIZE", UVec2(m_r->getWidth(), m_r->getHeight()))
.add("MOTION_BLUR_SAMPLES", U32(config.getNumber("r.final.motionBlurSamples")));
const ShaderProgramResourceVariant* variant;
m_prog->getOrCreateVariant(mutations.get(), consts.get(), variant);
m_grProgs[0] = variant->getProgram();
mutations[2].m_value = 1;
m_prog->getOrCreateVariant(mutations.get(), consts.get(), variant);
m_grProgs[1] = variant->getProgram();
return Error::NONE;
}
Error ShadowMapping::initEsm(const ConfigSet& cfg)
{
// Init RTs and FBs
{
m_esmTileResolution = cfg.getNumber("r.shadowMapping.tileResolution");
m_esmTileCountBothAxis = cfg.getNumber("r.shadowMapping.tileCountPerRowOrColumn");
// RT
TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(m_esmTileResolution * m_esmTileCountBothAxis,
m_esmTileResolution * m_esmTileCountBothAxis,
SHADOW_COLOR_PIXEL_FORMAT,
TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE
| TextureUsageBit::SAMPLED_COMPUTE,
"esm");
texinit.m_initialUsage = TextureUsageBit::SAMPLED_FRAGMENT;
ClearValue clearVal;
clearVal.m_colorf[0] = 1.0f;
m_esmAtlas = m_r->createAndClearRenderTarget(texinit, clearVal);
// FB
m_esmFbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::LOAD;
m_esmFbDescr.m_colorAttachmentCount = 1;
m_esmFbDescr.bake();
}
// Tiles
m_esmTileAlloc.init(getAllocator(), m_esmTileCountBothAxis, m_esmTileCountBothAxis, m_lodCount, true);
// Programs and shaders
{
ANKI_CHECK(
getResourceManager().loadResource("shaders/ExponentialShadowmappingResolve.glslp", m_esmResolveProg));
ShaderProgramResourceConstantValueInitList<1> consts(m_esmResolveProg);
consts.add("INPUT_TEXTURE_SIZE",
UVec2(m_scratchTileCountX * m_scratchTileResolution, m_scratchTileCountY * m_scratchTileResolution));
const ShaderProgramResourceVariant* variant;
m_esmResolveProg->getOrCreateVariant(consts.get(), variant);
m_esmResolveGrProg = variant->getProgram();
}
return Error::NONE;
}
Error ShadowMapping::initInternal(const ConfigSet& cfg)
{
ANKI_CHECK(initScratch(cfg));
ANKI_CHECK(initEsm(cfg));
m_lodDistances[0] = cfg.getNumber("r.shadowMapping.lightLodDistance0");
m_lodDistances[1] = cfg.getNumber("r.shadowMapping.lightLodDistance1");
return Error::NONE;
}
Error Ssr::initInternal(const ConfigSet& cfg)
{
U32 width = m_r->getWidth() / SSR_FRACTION;
U32 height = m_r->getHeight() / SSR_FRACTION;
ANKI_R_LOGI("Initializing SSR pass (%ux%u)", width, height);
// Create RTs
TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(width,
height,
Format::R16G16B16A16_SFLOAT,
TextureUsageBit::IMAGE_COMPUTE_READ_WRITE | TextureUsageBit::SAMPLED_FRAGMENT,
"SSR");
texinit.m_initialUsage = TextureUsageBit::SAMPLED_FRAGMENT;
m_rt = m_r->createAndClearRenderTarget(texinit);
// Create shader
ANKI_CHECK(getResourceManager().loadResource("shaders/Ssr.glslp", m_prog));
ShaderProgramResourceConstantValueInitList<5> consts(m_prog);
consts.add("FB_SIZE", UVec2(width, height));
consts.add("WORKGROUP_SIZE", UVec2(m_workgroupSize[0], m_workgroupSize[1]));
consts.add("MAX_STEPS", U32(cfg.getNumber("r.ssr.maxSteps")));
consts.add("LIGHT_BUFFER_MIP_COUNT", U32(m_r->getDownscaleBlur().getMipmapCount()));
consts.add("HISTORY_COLOR_BLEND_FACTOR", F32(cfg.getNumber("r.ssr.historyBlendFactor")));
ShaderProgramResourceMutationInitList<1> mutators(m_prog);
mutators.add("VARIANT", 0);
const ShaderProgramResourceVariant* variant;
m_prog->getOrCreateVariant(mutators.get(), consts.get(), variant);
m_grProg[0] = variant->getProgram();
mutators[0].m_value = 1;
m_prog->getOrCreateVariant(mutators.get(), consts.get(), variant);
m_grProg[1] = variant->getProgram();
return Error::NONE;
}
//==============================================================================
Error TransientMemoryManager::init(const ConfigSet& cfg)
{
Array<const char*, U(TransientBufferType::COUNT)> configVars = {
{"gr.uniformPerFrameMemorySize",
"gr.storagePerFrameMemorySize",
"gr.vertexPerFrameMemorySize",
"gr.transferPerFrameMemorySize"}};
const VkPhysicalDeviceLimits& limits =
m_manager->getImplementation().getPhysicalDeviceProperties().limits;
Array<U32, U(TransientBufferType::COUNT)> alignments = {
{U32(limits.minUniformBufferOffsetAlignment),
U32(limits.minStorageBufferOffsetAlignment),
sizeof(F32) * 4,
sizeof(F32) * 4}};
Array<BufferUsageBit, U(TransientBufferType::COUNT)> usages = {
{BufferUsageBit::UNIFORM_ANY_SHADER,
BufferUsageBit::STORAGE_ANY,
BufferUsageBit::VERTEX,
BufferUsageBit::TRANSFER_SOURCE}};
auto alloc = m_manager->getAllocator();
for(TransientBufferType i = TransientBufferType::UNIFORM;
i < TransientBufferType::COUNT;
++i)
{
PerFrameBuffer& frame = m_perFrameBuffers[i];
frame.m_size = cfg.getNumber(configVars[i]);
ANKI_ASSERT(frame.m_size);
// Create buffer
frame.m_buff = alloc.newInstance<BufferImpl>(m_manager);
ANKI_CHECK(frame.m_buff->init(
frame.m_size, usages[i], BufferMapAccessBit::WRITE));
frame.m_bufferHandle = frame.m_buff->getHandle();
// Map once
frame.m_mappedMem = static_cast<U8*>(
frame.m_buff->map(0, frame.m_size, BufferMapAccessBit::WRITE));
ANKI_ASSERT(frame.m_mappedMem);
// Init the allocator
frame.m_alloc.init(frame.m_size, alignments[i]);
}
return ErrorCode::NONE;
}
Error MainRenderer::create(ThreadPool* threadpool,
ResourceManager* resources,
GrManager* gr,
AllocAlignedCallback allocCb,
void* allocCbUserData,
const ConfigSet& config,
Timestamp* globTimestamp)
{
ANKI_LOGI("Initializing main renderer");
m_alloc = HeapAllocator<U8>(allocCb, allocCbUserData);
m_frameAlloc = StackAllocator<U8>(allocCb, allocCbUserData, 1024 * 1024 * 10, 1.0);
// Init default FB
m_width = config.getNumber("width");
m_height = config.getNumber("height");
FramebufferInitInfo fbInit;
fbInit.m_colorAttachmentCount = 1;
fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
m_defaultFb = gr->newInstance<Framebuffer>(fbInit);
// Init renderer and manipulate the width/height
ConfigSet config2 = config;
m_renderingQuality = config.getNumber("renderingQuality");
UVec2 size(m_renderingQuality * F32(m_width), m_renderingQuality * F32(m_height));
size.x() = getAlignedRoundDown(TILE_SIZE, size.x() / 2) * 2;
size.y() = getAlignedRoundDown(TILE_SIZE, size.y() / 2) * 2;
config2.set("width", size.x());
config2.set("height", size.y());
m_rDrawToDefaultFb = m_renderingQuality == 1.0;
m_r.reset(m_alloc.newInstance<Renderer>());
ANKI_CHECK(m_r->init(threadpool, resources, gr, m_alloc, m_frameAlloc, config2, globTimestamp, m_rDrawToDefaultFb));
// Set the default preprocessor string
m_materialShaderSource.sprintf(m_alloc,
"#define ANKI_RENDERER_WIDTH %u\n"
"#define ANKI_RENDERER_HEIGHT %u\n"
"#define TILE_SIZE %u\n",
m_r->getWidth(),
m_r->getHeight(),
TILE_SIZE);
// Init other
if(!m_rDrawToDefaultFb)
{
ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/Final.frag.glsl", m_blitFrag));
ColorStateInfo colorState;
colorState.m_attachmentCount = 1;
colorState.m_attachments[0].m_format.m_components = ComponentFormat::DEFAULT_FRAMEBUFFER;
m_r->createDrawQuadPipeline(m_blitFrag->getGrShader(), colorState, m_blitPpline);
// Init RC group
ResourceGroupInitInfo rcinit;
rcinit.m_textures[0].m_texture = m_r->getPps().getRt();
m_rcGroup = m_r->getGrManager().newInstance<ResourceGroup>(rcinit);
ANKI_LOGI("The main renderer will have to blit the offscreen renderer's result");
}
ANKI_LOGI("Main renderer initialized. Rendering size %ux%u", m_width, m_height);
return ErrorCode::NONE;
}
Error Dbg::init(const ConfigSet& initializer)
{
m_enabled = initializer.getNumber("dbg.enabled");
m_flags.set(DbgFlag::ALL);
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;
}
