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; }