Error Ssao::initBlur(const ConfigSet& config)
{
// shader
if(m_blurUseCompute)
{
ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/GaussianBlurCompute.glslp", m_blur.m_prog));
ShaderProgramResourceMutationInitList<3> mutators(m_blur.m_prog);
mutators.add("ORIENTATION", 2).add("KERNEL_SIZE", 3).add("COLOR_COMPONENTS", 1);
ShaderProgramResourceConstantValueInitList<2> consts(m_blur.m_prog);
consts.add("TEXTURE_SIZE", UVec2(m_width, m_height))
.add("WORKGROUP_SIZE", UVec2(m_workgroupSize[0], m_workgroupSize[1]));
const ShaderProgramResourceVariant* variant;
m_blur.m_prog->getOrCreateVariant(mutators.get(), consts.get(), variant);
m_blur.m_grProg = variant->getProgram();
}
else
{
ANKI_CHECK(m_r->getResourceManager().loadResource("shaders/GaussianBlur.glslp", m_blur.m_prog));
ShaderProgramResourceMutationInitList<3> mutators(m_blur.m_prog);
mutators.add("ORIENTATION", 2).add("KERNEL_SIZE", 3).add("COLOR_COMPONENTS", 1);
ShaderProgramResourceConstantValueInitList<1> consts(m_blur.m_prog);
consts.add("TEXTURE_SIZE", UVec2(m_width, m_height));
const ShaderProgramResourceVariant* variant;
m_blur.m_prog->getOrCreateVariant(mutators.get(), consts.get(), variant);
m_blur.m_grProg = variant->getProgram();
}
return Error::NONE;
}
bool activate(sc_wait_type type,sc_param *prm,int len)
{
boost::scoped_array<sc_addr> prms(new sc_addr[len+1]);
boost::scoped_array<bool> consts(new bool[len+1]);
prms[0] = descr;
consts[0] = true;
for (int i = 1;i < len + 1; ++i) {
consts[i] = true;
prms[i] = prm[i-1].addr;
if (prms[i]->seg->ring_0)
// just skip events in ring_0
return false;
}
if (descr->dead) {
descr->unref();
sc_segment *seg = create_unique_segment(system_session,"/tmp/bugfix");
descr = system_session->create_el(seg,SC_N_CONST);
descr->ref();
prms[0] = descr;
}
sc_addr son = create_orphaned_son(libsc_login(), proc, 0, 0, prms.get(), consts.get(), len + 1);
if (!son) {
fprintf(stderr,"Failed to start event handler. Event skiped\n");
return false;
}
if (pm_sched_add_agent(son,SCHED_CLASS_NORMAL))
SC_ABORT();
return false;
}
void cssRule() {
consts();
type();
cssText();
parentRule();
parentStyleSheet();
}
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 Ssao::initMain(const ConfigSet& config)
{
// Noise
ANKI_CHECK(getResourceManager().loadResource("engine_data/BlueNoiseLdrRgb64x64.ankitex", m_main.m_noiseTex));
// Shader
if(m_useCompute)
{
ANKI_CHECK(getResourceManager().loadResource("shaders/SsaoCompute.glslp", m_main.m_prog));
}
else
{
ANKI_CHECK(getResourceManager().loadResource("shaders/Ssao.glslp", m_main.m_prog));
}
ShaderProgramResourceMutationInitList<2> mutators(m_main.m_prog);
mutators.add("USE_NORMAL", (m_useNormal) ? 1u : 0u).add("SOFT_BLUR", (m_useSoftBlur) ? 1u : 0u);
ShaderProgramResourceConstantValueInitList<7> consts(m_main.m_prog);
consts.add("NOISE_MAP_SIZE", U32(m_main.m_noiseTex->getWidth()))
.add("FB_SIZE", UVec2(m_width, m_height))
.add("RADIUS", 2.5f)
.add("BIAS", 0.0f)
.add("STRENGTH", 2.5f)
.add("SAMPLE_COUNT", 8u)
.add("WORKGROUP_SIZE", UVec2(m_workgroupSize[0], m_workgroupSize[1]));
const ShaderProgramResourceVariant* variant;
m_main.m_prog->getOrCreateVariant(mutators.get(), consts.get(), variant);
m_main.m_grProg = variant->getProgram();
return Error::NONE;
}
CAMLprim value output_consts (value fname)
{
char *outf = String_val (fname);
FILE *fd;
if (strlen(outf) == 0) { fd = stdout; }
else
{
fd = fopen (outf, "w");
if (!fd) { perror(outf); exit (1); }
}
consts(fd);
fflush(fd);
if (fd != stdout) { fclose (fd); }
return Val_unit;
}
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 test_module()
{
v8pp::context context;
v8::HandleScope scope(context.isolate());
v8pp::module module(context.isolate());
v8pp::module consts(context.isolate());
consts
.set_const("bool", true)
.set_const("char", 'Z')
.set_const("int", 100)
.set_const("str", "str")
.set_const("num", 99.9)
;
module
.set("consts", consts)
.set("var", var)
.set("fun", &fun)
.set("empty", v8::Null(context.isolate()))
.set("rprop", v8pp::property(get_x))
.set("wprop", v8pp::property(get_x, set_x))
;
context.set("module", module);
check_eq("module.consts.bool", run_script<bool>(context, "module.consts.bool"), true);
check_eq("module.consts.char", run_script<char>(context, "module.consts.char"), 'Z');
check_eq("module.consts.int", run_script<char>(context, "module.consts.int"), 100);
check_eq("module.consts.str", run_script<std::string>(context, "module.consts.str"), "str");
check_eq("module.var", run_script<std::string>(context, "module.var = 'test'; module.var"), "test");
check_eq("var", var, "test");
check_eq("module.fun", run_script<int>(context, "module.fun(100)"), 101);
check_eq("module.rprop", run_script<int>(context, "module.rprop"), 2);
check_eq("module.wrop", run_script<int>(context, "++module.wprop"), 3);
check_eq("x", x, 2);
}
void CodeBuffer::freeze_section(CodeSection* cs) {
CodeSection* next_cs = (cs == consts())? NULL: code_section(cs->index()+1);
csize_t frozen_size = cs->size();
if (next_cs != NULL) {
frozen_size = next_cs->align_at_start(frozen_size);
}
address old_limit = cs->limit();
address new_limit = cs->start() + frozen_size;
relocInfo* old_locs_limit = cs->locs_limit();
relocInfo* new_locs_limit = cs->locs_end();
// Patch the limits.
cs->_limit = new_limit;
cs->_locs_limit = new_locs_limit;
cs->_frozen = true;
if (!next_cs->is_allocated() && !next_cs->is_frozen()) {
// Give remaining buffer space to the following section.
next_cs->initialize(new_limit, old_limit - new_limit);
next_cs->initialize_shared_locs(new_locs_limit,
old_locs_limit - new_locs_limit);
}
}
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;
}
