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;
}
void CExternalChannel::CFrontEnd::MParseDemands(const NSHARE::CConfig& aConf)
{
const ConfigSet _dems = aConf.MChildren(DEMAND);
LOG_IF(WARNING,_dems.empty()) << "No demands ";
if (!_dems.empty())
{
ConfigSet::const_iterator _it = _dems.begin();
for (; _it != _dems.end(); ++_it)
{
VLOG(2) << "dem info " << *_it;
demand_dg_t _dem(*_it);
_dem.FHandler = 0;
LOG_IF(ERROR,!_dem.MIsValid()) << "Cannot create demands from "
<< _it->MToJSON(true);
if (_dem.MIsValid())
{
LOG(INFO)<<"Demand "<<_dem;
FDemands.push_back(_dem);
FSendProtocol.insert(_dem.FProtocol);
}
}
}
if (aConf.MIsChild(RECV_PROTOCOL))
{
VLOG(2) << "There is exit protocol";
FReceiveProtocol=aConf.MChild(RECV_PROTOCOL).MValue();
LOG_IF(FATAL,!FReceiveProtocol.empty() && !CParserFactory::sMGetInstance().MIsFactoryPresent(FReceiveProtocol))
<< "The protocol handler is not exist."<<FReceiveProtocol;
}
}
const ConfigSet Config::children( const std::string& key ) const {
ConfigSet r;
for(ConfigSet::const_iterator i = _children.begin(); i != _children.end(); i++ ) {
if ( (i)->key() == key )
r.push_back( *i );
}
return r;
}
void
KML_Model::parseStyle(const Config& conf, KMLContext& cx, Style& style)
{
ModelSymbol* model = 0L;
std::string url = KMLUtils::parseLink(conf);
if ( !url.empty() )
{
if ( !model ) model = style.getOrCreate<ModelSymbol>();
model->url()->setLiteral( url );
model->url()->setURIContext( URIContext(conf.referrer()) );
}
Config scale = conf.child("scale");
if (!scale.empty())
{
if ( !model ) model = style.getOrCreate<ModelSymbol>();
//TODO: Support XYZ scale instead of single value
model->scale() = scale.value("x", 1.0);
}
Config orientation = conf.child("orientation");
if (!orientation.empty())
{
if ( !model ) model = style.getOrCreate<ModelSymbol>();
double h = orientation.value("heading", 0);
if ( !osg::equivalent(h, 0.0) )
model->heading() = NumericExpression( h );
double p = orientation.value("tilt", 0);
if ( !osg::equivalent(p, 0.0) )
model->pitch() = NumericExpression( p );
double r = orientation.value("roll", 0);
if ( !osg::equivalent(r, 0.0) )
model->roll() = NumericExpression( r );
}
// Read and store file path aliases from a KML ResourceMap.
Config resource_map = conf.child("resourcemap");
if ( !resource_map.empty() )
{
const ConfigSet aliases = resource_map.children("alias");
for( ConfigSet::const_iterator i = aliases.begin(); i != aliases.end(); ++i )
{
std::string source = i->value("sourcehref");
std::string target = i->value("targethref");
if ( !source.empty() || !target.empty() )
{
if ( !model ) model = style.getOrCreate<ModelSymbol>();
model->uriAliasMap()->insert( source, target );
}
}
}
KML_Geometry::parseStyle(conf, cx, style);
}
void
FeatureDisplayLayout::fromConfig( const Config& conf )
{
conf.getIfSet( "tile_size_factor", _tileSizeFactor );
conf.getIfSet( "crop_features", _cropFeatures );
ConfigSet children = conf.children( "level" );
for( ConfigSet::const_iterator i = children.begin(); i != children.end(); ++i )
addLevel( FeatureLevel( *i ) );
}
void
LandCoverCoverageLayerOptions::fromConfig(const Config& conf)
{
ConfigSet mappings = conf.child("land_cover_mappings").children("mapping");
for (ConfigSet::const_iterator i = mappings.begin(); i != mappings.end(); ++i)
{
osg::ref_ptr<LandCoverValueMapping> mapping = new LandCoverValueMapping(*i);
_valueMappings.push_back(mapping.get());
}
conf.get("warp", _warp);
}
void
ResourceLibrary::mergeConfig( const Config& conf )
{
// read skins
const ConfigSet skins = conf.children( "skin" );
for( ConfigSet::const_iterator i = skins.begin(); i != skins.end(); ++i )
{
addResource( new SkinResource(*i) );
}
//todo: other types later..
}
bool Display::initialize()
{
if (isInitialized())
{
return true;
}
mRenderer = glCreateRenderer(this, mDisplayId, mRequestedDisplayType);
if (!mRenderer)
{
terminate();
return error(EGL_NOT_INITIALIZED, false);
}
EGLint minSwapInterval = mRenderer->getMinSwapInterval();
EGLint maxSwapInterval = mRenderer->getMaxSwapInterval();
EGLint maxTextureSize = mRenderer->getRendererCaps().max2DTextureSize;
rx::ConfigDesc *descList;
int numConfigs = mRenderer->generateConfigs(&descList);
ConfigSet configSet;
for (int i = 0; i < numConfigs; ++i)
{
configSet.add(descList[i], minSwapInterval, maxSwapInterval, maxTextureSize, maxTextureSize);
}
// Give the sorted configs a unique ID and store them internally
EGLint index = 1;
for (ConfigSet::Iterator config = configSet.mSet.begin(); config != configSet.mSet.end(); config++)
{
Config configuration = *config;
configuration.mConfigID = index;
index++;
mConfigSet.mSet.insert(configuration);
}
mRenderer->deleteConfigs(descList);
descList = NULL;
if (!isInitialized())
{
terminate();
return false;
}
initDisplayExtensionString();
initVendorString();
return true;
}
void
ShaderOptions::fromConfig(const Config& conf)
{
_code = conf.value();
_samplers.clear();
ConfigSet s = conf.children("sampler");
for (ConfigSet::const_iterator i = s.begin(); i != s.end(); ++i) {
_samplers.push_back(Sampler());
_samplers.back()._name = i->value("name");
const Config* urlarray = i->find("array");
if (urlarray) {
ConfigSet uris = urlarray->children("url");
for (ConfigSet::const_iterator j = uris.begin(); j != uris.end(); ++j) {
URI uri(j->value(), URIContext(conf.referrer()));
_samplers.back()._uris.push_back(uri);
}
}
else {
optional<URI> uri;
i->get("url", uri);
if (uri.isSet())
_samplers.back()._uris.push_back(uri.get());
}
}
s = conf.children("uniform");
for (ConfigSet::const_iterator i = s.begin(); i != s.end(); ++i) {
_uniforms.push_back(Uniform());
_uniforms.back()._name = i->value("name");
i->get("value", _uniforms.back()._value);
}
}
DoctypeFixture *addDocType(const std::string &name, bool isGlobal = false) {
DocumenttypesConfigBuilder::Documenttype dt;
dt.bodystruct = -1270491200;
dt.headerstruct = 306916075;
dt.id = idcounter--;
dt.name = name;
dt.version = 0;
documenttypesBuilder.documenttype.push_back(dt);
ProtonConfigBuilder::Documentdb db;
db.inputdoctypename = name;
db.configid = configId + "/" + name;
db.global = isGlobal;
protonBuilder.documentdb.push_back(db);
DoctypeFixture::UP fixture = std::make_unique<DoctypeFixture>();
set.addBuilder(db.configid, &fixture->attributesBuilder);
set.addBuilder(db.configid, &fixture->rankProfilesBuilder);
set.addBuilder(db.configid, &fixture->rankingConstantsBuilder);
set.addBuilder(db.configid, &fixture->indexschemaBuilder);
set.addBuilder(db.configid, &fixture->summaryBuilder);
set.addBuilder(db.configid, &fixture->summarymapBuilder);
set.addBuilder(db.configid, &fixture->juniperrcBuilder);
set.addBuilder(db.configid, &fixture->importedFieldsBuilder);
return dbConfig.emplace(std::make_pair(name, std::move(fixture))).first->second.get();
}
void
URI::mergeConfig(const Config& conf)
{
conf.get("option_string", _optionString);
const ConfigSet headers = conf.child("headers").children();
for (ConfigSet::const_iterator i = headers.begin(); i != headers.end(); ++i)
{
const Config& header = *i;
if (!header.key().empty() && !header.value().empty())
{
_context.addHeader(header.key(), header.value());
}
}
}
void
FeatureDisplayLayout::fromConfig( const Config& conf )
{
conf.getIfSet( "tile_size", _tileSize );
conf.getIfSet( "tile_size_factor", _tileSizeFactor );
conf.getIfSet( "crop_features", _cropFeatures );
conf.getIfSet( "priority_offset", _priorityOffset );
conf.getIfSet( "priority_scale", _priorityScale );
conf.getIfSet( "min_expiry_time", _minExpiryTime );
conf.getIfSet( "min_range", _minRange );
conf.getIfSet( "max_range", _maxRange );
ConfigSet children = conf.children( "level" );
for( ConfigSet::const_iterator i = children.begin(); i != children.end(); ++i )
addLevel( FeatureLevel( *i ) );
}
//==============================================================================
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
FeatureLevel::fromConfig( const Config& conf )
{
if ( conf.hasValue( "min_range" ) )
_minRange = conf.value( "min_range", 0.0f );
if ( conf.hasValue( "max_range" ) )
_maxRange = conf.value( "max_range", FLT_MAX );
conf.getIfSet( "lod", _lod );
const ConfigSet selectorsConf = conf.children( "selector" );
for( ConfigSet::const_iterator i = selectorsConf.begin(); i != selectorsConf.end(); ++i )
{
_selectors.push_back( StyleSelector(*i) );
}
}
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;
}
ConfigTestFixture(const std::string & id)
: configId(id),
protonBuilder(),
documenttypesBuilder(),
filedistBuilder(),
bucketspacesBuilder(),
dbConfig(),
set(),
context(new ConfigContext(set)),
idcounter(-1)
{
set.addBuilder(configId, &protonBuilder);
set.addBuilder(configId, &documenttypesBuilder);
set.addBuilder(configId, &filedistBuilder);
set.addBuilder(configId, &bucketspacesBuilder);
addDocType("_alwaysthere_");
}
void
TextureSplatter::mergeConfig(const Config& conf)
{
conf.getIfSet( "start_lod", _startLOD );
conf.getIfSet( "intensity", _intensity );
conf.getIfSet( "scale", _scale );
conf.getIfSet( "attenuation_distance", _attenuationDistance );
conf.getIfSet( "mask_layer", _maskLayerName );
ConfigSet textures = conf.child("textures").children("texture");
for(ConfigSet::iterator i = textures.begin(); i != textures.end(); ++i)
{
_textures.push_back(TextureSource());
_textures.back()._tag = i->value("tag");
_textures.back()._url = i->value("url");
}
}
void
Style::mergeConfig( const Config& conf )
{
if ( _name.empty() )
_name = conf.value( "name" );
// if there's no explicit name, use the KEY as the name.
if ( _name.empty() )
_name = conf.key();
conf.getIfSet( "url", _uri ); // named "url" for back compat
_origType = conf.value( "type" );
std::string textData = trim(conf.value());
bool useCSS =
_origType.compare("text/css") == 0 ||
!textData.empty();
if ( useCSS )
{
_origData = textData;
// just take the first block.
ConfigSet blocks;
CssUtils::readConfig( _origData, conf.referrer(), blocks );
if ( blocks.size() > 0 )
{
fromSLD( blocks.front() );
}
}
else
{
Config symbolConf = conf.child( "symbols" );
if ( !symbolConf.empty() )
{
for( ConfigSet::const_iterator i = symbolConf.children().begin(); i != symbolConf.children().end(); ++i )
{
const Config& c = *i;
Symbol* symbol = SymbolRegistry::instance()->create( c );
add(symbol);
}
}
}
}
void
CssUtils::readConfig( const std::string& css, const std::string& referrer, ConfigSet& output )
{
ConfigSet result;
// if there's no brackets, assume this is a single default block.
std::string temp = css;
if ( css.find_first_of("{") == std::string::npos )
{
temp = "default { " + css + " }";
}
else if ( css.size() > 0 && css[0] == '{' )
{
temp = "default " + css;
}
// tokenize the CSS into a config object..
Config conf( "css" );
StringTokenizer blockIzer( "{}", "" );
blockIzer.addQuotes( "'\"", true );
StringTokenizer propSetIzer( ";", "" );
propSetIzer.addQuotes( "'\"", true );
StringTokenizer propIzer( ":", "" );
propIzer.addQuotes( "()'\"", true );
StringVector blocks;
blockIzer.tokenize( temp, blocks );
for( unsigned i=0; i<blocks.size(); )
{
const std::string& name = blocks[i++];
if ( i < blocks.size() )
{
Config elementConf( name );
elementConf.setReferrer( referrer );
StringVector propSet;
propSetIzer.tokenize( blocks[i++], propSet );
for( unsigned j=0; j<propSet.size(); ++j )
{
StringVector prop;
propIzer.tokenize( propSet[j], prop );
if ( prop.size() == 2 )
{
elementConf.set( prop[0], prop[1] );
}
}
output.push_back( elementConf );
}
}
}
DataManager::DataManager(osgEarth::MapNode* mapNode) : _mapNode(mapNode), _maxUndoStackSize( 128 )
{
if (_mapNode)
{
_map = _mapNode->getMap();
//Look for viewpoints in the MapNode externals
const Config& externals = _mapNode->externalConfig();
const ConfigSet children = externals.children("viewpoint");
if (children.size() > 0)
{
for( ConfigSet::const_iterator i = children.begin(); i != children.end(); ++i )
_viewpoints.push_back(Viewpoint(*i));
}
}
initialize();
}
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;
}
//==============================================================================
void Pps::initInternal(const ConfigSet& initializer)
{
m_enabled = initializer.get("pps.enabled");
if(!m_enabled)
{
return;
}
ANKI_ASSERT("Initializing PPS");
m_ssao.init(initializer);
m_hdr.init(initializer);
m_lf.init(initializer);
m_sslr.init(initializer);
// FBO
GlDevice& gl = GlDeviceSingleton::get();
GlCommandBufferHandle jobs(&gl);
m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(), GL_RGB8, GL_RGB,
GL_UNSIGNED_BYTE, 1, m_rt);
m_fb = GlFramebufferHandle(jobs, {{m_rt, GL_COLOR_ATTACHMENT0}});
// SProg
std::stringstream pps;
pps << "#define SSAO_ENABLED " << (U)m_ssao.getEnabled() << "\n"
<< "#define HDR_ENABLED " << (U)m_hdr.getEnabled() << "\n"
<< "#define SHARPEN_ENABLED " << (U)initializer.get("pps.sharpen")
<< "\n"
<< "#define GAMMA_CORRECTION_ENABLED "
<< (U)initializer.get("pps.gammaCorrection") << "\n"
<< "#define FBO_WIDTH " << (U)m_r->getWidth() << "\n"
<< "#define FBO_HEIGHT " << (U)m_r->getHeight() << "\n";
m_frag.load(ProgramResource::createSrcCodeToCache(
"shaders/Pps.frag.glsl", pps.str().c_str(), "r_").c_str());
m_ppline = m_r->createDrawQuadProgramPipeline(m_frag->getGlProgram());
jobs.finish();
}
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;
}
void
SplatCoverageLegend::fromConfig(const Config& conf)
{
conf.get("name", _name);
conf.get("source", _source);
ConfigSet predicatesConf = conf.child("mappings").children();
for(ConfigSet::const_iterator i = predicatesConf.begin(); i != predicatesConf.end(); ++i)
{
osg::ref_ptr<CoverageValuePredicate> p = new CoverageValuePredicate();
i->get( "name", p->_description );
i->get( "value", p->_exactValue );
i->get( "class", p->_mappedClassName );
if ( p->_mappedClassName.isSet() )
{
_predicates.push_back( p.get() );
}
}
}
bool
ServiceReader::read( const Config& conf, RESTResponse& response )
{
response.getServices().clear();
response.getFolders().clear();
if (conf.hasChild("currentVersion"))
{
response.setCurrentVersion( conf.value("currentVersion") );
}
if (conf.hasChild("services"))
{
ConfigSet services = conf.child("services").children();
for (ConfigSet::iterator itr = services.begin(); itr != services.end(); ++itr)
{
response.getServices().push_back( Service( itr->value("name"), itr->value("type") ) );
}
}
if (conf.hasChild("folders"))
{
ConfigSet folders = conf.child("folders").children();
for (ConfigSet::iterator itr = folders.begin(); itr != folders.end(); ++itr)
{
response.getFolders().push_back( itr->value() );
}
}
return true;
}
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;
}
//==============================================================================
void Renderer::init(const ConfigSet& initializer)
{
// Set from the initializer
m_width = initializer.get("width");
m_height = initializer.get("height");
m_lodDistance = initializer.get("lodDistance");
m_framesNum = 0;
m_samples = initializer.get("samples");
m_isOffscreen = initializer.get("offscreen");
m_renderingQuality = initializer.get("renderingQuality");
m_tilesCount.x() = initializer.get("tilesXCount");
m_tilesCount.y() = initializer.get("tilesYCount");
m_tessellation = initializer.get("tessellation");
// A few sanity checks
if(m_samples != 1 && m_samples != 4 && m_samples != 8 && m_samples != 16
&& m_samples != 32)
{
throw ANKI_EXCEPTION("Incorrect samples");
}
if(m_width < 10 || m_height < 10)
{
throw ANKI_EXCEPTION("Incorrect sizes");
}
// quad setup
static const F32 quadVertCoords[][2] = {{1.0, 1.0}, {-1.0, 1.0},
{1.0, -1.0}, {-1.0, -1.0}};
GlDevice& gl = GlDeviceSingleton::get();
GlCommandBufferHandle jobs(&gl);
GlClientBufferHandle tmpBuff = GlClientBufferHandle(jobs,
sizeof(quadVertCoords), (void*)&quadVertCoords[0][0]);
m_quadPositionsBuff = GlBufferHandle(jobs, GL_ARRAY_BUFFER,
tmpBuff, 0);
m_drawQuadVert.load("shaders/Quad.vert.glsl");
// Init the stages. Careful with the order!!!!!!!!!!
m_tiler.init(this);
m_ms.init(initializer);;
m_is.init(initializer);
m_bs.init(initializer);
m_pps.init(initializer);
m_dbg.init(initializer);
// Init the shaderPostProcessorString
std::stringstream ss;
ss << "#define RENDERING_WIDTH " << m_width << "\n"
<< "#define RENDERING_HEIGHT " << m_height << "\n";
m_shaderPostProcessorString = ss.str();
// Default FB
m_defaultFb = GlFramebufferHandle(jobs, {});
jobs.finish();
}
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;
}
