// static int QPpsObject::sendMessage(const QString &path, const QString &message) { QPpsObject pps(path); bool ok = pps.open(QPpsObject::Publish); if (!ok) return pps.error(); ok = pps.write(message.toLocal8Bit()); if (!ok) return pps.error(); return EOK; }
// static int QPpsObject::sendMessage(const QString &path, const QByteArray &ppsData) { QPpsObject pps(path); bool ok = pps.open(QPpsObject::Publish); if (!ok) return pps.error(); ok = pps.write(ppsData); if (!ok) return pps.error(); return EOK; }
bool PrintingParent::RecvShowProgress(PBrowserParent* parent, PPrintProgressDialogParent* printProgressDialog, PRemotePrintJobParent* remotePrintJob, const bool& isForPrinting, bool* notifyOnOpen, nsresult* result) { *result = NS_ERROR_FAILURE; *notifyOnOpen = false; nsCOMPtr<nsPIDOMWindowOuter> parentWin = DOMWindowFromBrowserParent(parent); if (!parentWin) { return true; } nsCOMPtr<nsIPrintingPromptService> pps(do_GetService("@mozilla.org/embedcomp/printingprompt-service;1")); if (!pps) { return true; } PrintProgressDialogParent* dialogParent = static_cast<PrintProgressDialogParent*>(printProgressDialog); nsCOMPtr<nsIObserver> observer = do_QueryInterface(dialogParent); nsCOMPtr<nsIWebProgressListener> printProgressListener; nsCOMPtr<nsIPrintProgressParams> printProgressParams; *result = pps->ShowProgress(parentWin, nullptr, nullptr, observer, isForPrinting, getter_AddRefs(printProgressListener), getter_AddRefs(printProgressParams), notifyOnOpen); NS_ENSURE_SUCCESS(*result, true); if (remotePrintJob) { // If we have a RemotePrintJob use that as a more general forwarder for // print progress listeners. static_cast<RemotePrintJobParent*>(remotePrintJob) ->RegisterListener(printProgressListener); } else { dialogParent->SetWebProgressListener(printProgressListener); } dialogParent->SetPrintProgressParams(printProgressParams); return true; }
//============================================================================== 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(); }
// static int QPpsObject::sendMessage(const QString &path, const QVariantMap &message) { QPpsObject pps(path); bool ok = pps.open(QPpsObject::Publish); if (!ok) return pps.error(); QByteArray payload = QPpsObject::encode(message, &ok); if (!ok) return -1; ok = pps.write(payload); if (!ok) return pps.error(); return EOK; }
nsresult PrintingParent::ShowPrintDialog(PBrowserParent* aParent, const PrintData& aData, PrintData* aResult) { nsCOMPtr<nsIDOMWindow> parentWin = DOMWindowFromBrowserParent(aParent); if (!parentWin) { return NS_ERROR_FAILURE; } nsCOMPtr<nsIPrintingPromptService> pps(do_GetService("@mozilla.org/embedcomp/printingprompt-service;1")); if (!pps) { return NS_ERROR_FAILURE; } // The initSettings we got can be wrapped using // PrintDataUtils' MockWebBrowserPrint, which implements enough of // nsIWebBrowserPrint to keep the dialogs happy. nsCOMPtr<nsIWebBrowserPrint> wbp = new MockWebBrowserPrint(aData); nsresult rv; nsCOMPtr<nsIPrintOptions> po = do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIPrintSettings> settings; rv = po->CreatePrintSettings(getter_AddRefs(settings)); NS_ENSURE_SUCCESS(rv, rv); rv = po->DeserializeToPrintSettings(aData, settings); NS_ENSURE_SUCCESS(rv, rv); rv = pps->ShowPrintDialog(parentWin, wbp, settings); NS_ENSURE_SUCCESS(rv, rv); // And send it back. rv = po->SerializeToPrintData(settings, nullptr, aResult); PRemotePrintJobParent* remotePrintJob = new RemotePrintJobParent(settings); aResult->remotePrintJobParent() = SendPRemotePrintJobConstructor(remotePrintJob); return rv; }
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; }
bool PrintingParent::RecvShowProgress(PBrowserParent* parent, PPrintProgressDialogParent* printProgressDialog, const bool& isForPrinting, bool* notifyOnOpen, nsresult* result) { *result = NS_ERROR_FAILURE; *notifyOnOpen = false; nsCOMPtr<nsIDOMWindow> parentWin = DOMWindowFromBrowserParent(parent); if (!parentWin) { return true; } nsCOMPtr<nsIPrintingPromptService> pps(do_GetService("@mozilla.org/embedcomp/printingprompt-service;1")); if (!pps) { return true; } PrintProgressDialogParent* dialogParent = static_cast<PrintProgressDialogParent*>(printProgressDialog); nsCOMPtr<nsIObserver> observer = do_QueryInterface(dialogParent); nsCOMPtr<nsIWebProgressListener> printProgressListener; nsCOMPtr<nsIPrintProgressParams> printProgressParams; *result = pps->ShowProgress(parentWin, nullptr, nullptr, observer, isForPrinting, getter_AddRefs(printProgressListener), getter_AddRefs(printProgressParams), notifyOnOpen); NS_ENSURE_SUCCESS(*result, true); dialogParent->SetWebProgressListener(printProgressListener); dialogParent->SetPrintProgressParams(printProgressParams); return true; }
// static int QPpsObject::sendMessage(const QString &path, const QString &msg, const QVariantMap &dat) { // Treat empty msg as an encoding error if (msg.isEmpty()) return -1; QPpsObject pps(path); bool ok = pps.open(QPpsObject::Publish); if (!ok) return pps.error(); QByteArray payload = QPpsObject::encodeMessage(msg, dat, &ok); if (!ok) return -1; ok = pps.write(payload); if (!ok) return pps.error(); return EOK; }
nsresult PrintingParent::ShowPrintDialog(PBrowserParent* aParent, const PrintData& aData, PrintData* aResult) { nsCOMPtr<nsPIDOMWindowOuter> parentWin = DOMWindowFromBrowserParent(aParent); if (!parentWin) { return NS_ERROR_FAILURE; } nsCOMPtr<nsIPrintingPromptService> pps(do_GetService("@mozilla.org/embedcomp/printingprompt-service;1")); if (!pps) { return NS_ERROR_FAILURE; } // The initSettings we got can be wrapped using // PrintDataUtils' MockWebBrowserPrint, which implements enough of // nsIWebBrowserPrint to keep the dialogs happy. nsCOMPtr<nsIWebBrowserPrint> wbp = new MockWebBrowserPrint(aData); nsCOMPtr<nsIPrintSettings> settings; nsresult rv = mPrintSettingsSvc->GetNewPrintSettings(getter_AddRefs(settings)); NS_ENSURE_SUCCESS(rv, rv); rv = mPrintSettingsSvc->DeserializeToPrintSettings(aData, settings); NS_ENSURE_SUCCESS(rv, rv); rv = pps->ShowPrintDialog(parentWin, wbp, settings); NS_ENSURE_SUCCESS(rv, rv); // Serialize back to aResult. Use the existing RemotePrintJob if we have one // otherwise SerializeAndEnsureRemotePrintJob() will create a new one. RemotePrintJobParent* remotePrintJob = static_cast<RemotePrintJobParent*>(aData.remotePrintJobParent()); rv = SerializeAndEnsureRemotePrintJob(settings, nullptr, remotePrintJob, aResult); return rv; }
LONG SCardConnectA2(IN SCARDCONTEXT hContext, IN LPCSTR szReader, IN DWORD dwShareMode, IN DWORD dwPreferredProtocols, OUT LPSCARDHANDLE phCard, OUT LPDWORD pdwActiveProtocol) { typedef LONG (__stdcall * pS)(IN SCARDCONTEXT hContext, IN LPCSTR szReader, IN DWORD dwShareMode, IN DWORD dwPreferredProtocols, OUT LPSCARDHANDLE phCard, OUT LPDWORD pdwActiveProtocol); pS pps = (pS) p[7]; LONG result = 0; //lookup SoftReader by soft name //eidmw::pcscproxy::SoftReader *sr = srmngr->getSoftReaderByName(szReader, eidmw::pcscproxy::N_SOFT); // SoftReader *sr = new SoftReader(*iter, softname); std::string hardname = "ACS ACR38U 0"; std::string softname = "!Virtual ACS ACR38U 0"; eidmw::pcscproxy::SoftReader *sr = new SoftReader(hardname, softname); if (sr) { const std::string hardname = sr->getHardReaderName(); //result = pps(hContext, hardname.c_str(), dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol); *phCard = 3925934080; *pdwActiveProtocol = 1; if (SCARD_S_SUCCESS == result) { //connect to hard card was successful so now create a soft card *phCard = sr->createSoftCard(*phCard)->getSoftHandle(); } } else { //apparently szReader is a hard name so we send the request to the //original dll and be done with it result = pps(hContext, szReader, dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol); } return result; }
void GetHeaders(DataPacket &packet) { if(!HeaderPacket.Num()) { IPCSignalledType<spspps_size> spspps((event_prefix + SPSPPS_SIZES).Array()); IPCSignalledArray<mfxU8> sps((event_prefix + SPS_BUFF).Array(), spspps->sps_size), pps((event_prefix + PPS_BUFF).Array(), spspps->pps_size); IPCWaiter spspps_waiter = process_waiter; spspps_waiter.push_back(spspps.signal_); if(!spspps_waiter.wait_for(2, INFINITE)) return; BufferOutputSerializer headerOut(HeaderPacket); headerOut.OutputByte(0x17); headerOut.OutputByte(0); headerOut.OutputByte(0); headerOut.OutputByte(0); headerOut.OutputByte(0); headerOut.OutputByte(1); headerOut.Serialize(sps+5, 3); headerOut.OutputByte(0xff); headerOut.OutputByte(0xe1); headerOut.OutputWord(htons(spspps->sps_size-4)); headerOut.Serialize(sps+4, spspps->sps_size-4); headerOut.OutputByte(1); headerOut.OutputWord(htons(spspps->pps_size-4)); headerOut.Serialize(pps+4, spspps->pps_size-4); } packet.lpPacket = HeaderPacket.Array(); packet.size = HeaderPacket.Num(); }
//============================================================================== void Hdr::initInternal(const ConfigSet& initializer) { m_enabled = initializer.get("pps.hdr.enabled"); if(!m_enabled) { return; } const F32 renderingQuality = initializer.get("pps.hdr.renderingQuality"); m_width = renderingQuality * (F32)m_r->getWidth(); alignRoundDown(16, m_width); m_height = renderingQuality * (F32)m_r->getHeight(); alignRoundDown(16, m_height); m_exposure = initializer.get("pps.hdr.exposure"); m_blurringDist = initializer.get("pps.hdr.blurringDist"); m_blurringIterationsCount = initializer.get("pps.hdr.blurringIterationsCount"); initFb(m_hblurFb, m_hblurRt); initFb(m_vblurFb, m_vblurRt); // init shaders GlDevice& gl = getGlDevice(); GlCommandBufferHandle jobs(&gl); m_commonBuff = GlBufferHandle(jobs, GL_SHADER_STORAGE_BUFFER, sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT); updateDefaultBlock(jobs); jobs.flush(); m_toneFrag.load("shaders/PpsHdr.frag.glsl", &getResourceManager()); m_tonePpline = m_r->createDrawQuadProgramPipeline(m_toneFrag->getGlProgram()); const char* SHADER_FILENAME = "shaders/VariableSamplingBlurGeneric.frag.glsl"; String pps(getAllocator()); pps.sprintf("#define HPASS\n" "#define COL_RGB\n" "#define BLURRING_DIST float(%f)\n" "#define IMG_DIMENSION %u\n" "#define SAMPLES %u\n", m_blurringDist, m_height, static_cast<U>(initializer.get("pps.hdr.samples"))); m_hblurFrag.load(ProgramResource::createSourceToCache( SHADER_FILENAME, pps.toCString(), "r_", getResourceManager()).toCString(), &getResourceManager()); m_hblurPpline = m_r->createDrawQuadProgramPipeline(m_hblurFrag->getGlProgram()); pps.sprintf("#define VPASS\n" "#define COL_RGB\n" "#define BLURRING_DIST float(%f)\n" "#define IMG_DIMENSION %u\n" "#define SAMPLES %u\n", m_blurringDist, m_width, static_cast<U>(initializer.get("pps.hdr.samples"))); m_vblurFrag.load(ProgramResource::createSourceToCache( SHADER_FILENAME, pps.toCString(), "r_", getResourceManager()).toCString(), &getResourceManager()); m_vblurPpline = m_r->createDrawQuadProgramPipeline(m_vblurFrag->getGlProgram()); // Set timestamps m_parameterUpdateTimestamp = getGlobTimestamp(); m_commonUboUpdateTimestamp = getGlobTimestamp(); }
//============================================================================== void Ssao::initInternal(const ConfigSet& config) { m_enabled = config.get("pps.ssao.enabled"); if(!m_enabled) { return; } m_blurringIterationsCount = config.get("pps.ssao.blurringIterationsCount"); // // Init the widths/heights // const F32 quality = config.get("pps.ssao.renderingQuality"); m_width = quality * (F32)m_r->getWidth(); alignRoundUp(16, m_width); m_height = quality * (F32)m_r->getHeight(); alignRoundUp(16, m_height); // // create FBOs // createFb(m_hblurFb, m_hblurRt); createFb(m_vblurFb, m_vblurRt); // // noise texture // GlCommandBufferHandle cmdb; cmdb.create(&getGlDevice()); GlClientBufferHandle noise; noise.create( cmdb, sizeof(Vec3) * NOISE_TEX_SIZE * NOISE_TEX_SIZE, nullptr); genNoise((Vec3*)noise.getBaseAddress(), (Vec3*)((U8*)noise.getBaseAddress() + noise.getSize())); GlTextureHandle::Initializer tinit; tinit.m_width = tinit.m_height = NOISE_TEX_SIZE; tinit.m_target = GL_TEXTURE_2D; tinit.m_internalFormat = GL_RGB32F; tinit.m_format = GL_RGB; tinit.m_type = GL_FLOAT; tinit.m_filterType = GlTextureHandle::Filter::NEAREST; tinit.m_repeat = true; tinit.m_mipmapsCount = 1; tinit.m_data[0][0] = noise; m_noiseTex.create(cmdb, tinit); // // Kernel // String kernelStr(getAllocator()); Array<Vec3, KERNEL_SIZE> kernel; genKernel(kernel.begin(), kernel.end()); kernelStr = "vec3[]("; for(U i = 0; i < kernel.size(); i++) { String tmp(getAllocator()); tmp.sprintf("vec3(%f, %f, %f) %s", kernel[i].x(), kernel[i].y(), kernel[i].z(), (i != kernel.size() - 1) ? ", " : ")"); kernelStr += tmp; } // // Shaders // m_uniformsBuff.create(cmdb, GL_SHADER_STORAGE_BUFFER, sizeof(ShaderCommonUniforms), GL_DYNAMIC_STORAGE_BIT); String pps(getAllocator()); // main pass prog pps.sprintf( "#define NOISE_MAP_SIZE %u\n" "#define WIDTH %u\n" "#define HEIGHT %u\n" "#define KERNEL_SIZE %u\n" "#define KERNEL_ARRAY %s\n", NOISE_TEX_SIZE, m_width, m_height, KERNEL_SIZE, &kernelStr[0]); m_ssaoFrag.loadToCache(&getResourceManager(), "shaders/PpsSsao.frag.glsl", pps.toCString(), "r_"); m_ssaoPpline = m_r->createDrawQuadProgramPipeline( m_ssaoFrag->getGlProgram()); // blurring progs const char* SHADER_FILENAME = "shaders/VariableSamplingBlurGeneric.frag.glsl"; pps.sprintf( "#define HPASS\n" "#define COL_R\n" "#define IMG_DIMENSION %u\n" "#define SAMPLES 7\n", m_height); m_hblurFrag.loadToCache(&getResourceManager(), SHADER_FILENAME, pps.toCString(), "r_"); m_hblurPpline = m_r->createDrawQuadProgramPipeline( m_hblurFrag->getGlProgram()); pps.sprintf( "#define VPASS\n" "#define COL_R\n" "#define IMG_DIMENSION %u\n" "#define SAMPLES 7\n", m_width); m_vblurFrag.loadToCache(&getResourceManager(), SHADER_FILENAME, pps.toCString(), "r_"); m_vblurPpline = m_r->createDrawQuadProgramPipeline( m_vblurFrag->getGlProgram()); cmdb.flush(); }
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; }
nsresult PrintingParent::ShowPrintDialog(PBrowserParent* aParent, const PrintData& aData, PrintData* aResult) { // If aParent is null this call is just being used to get print settings from // the printer for print preview. bool isPrintPreview = !aParent; nsCOMPtr<nsPIDOMWindowOuter> parentWin; if (aParent) { parentWin = DOMWindowFromBrowserParent(aParent); if (!parentWin) { return NS_ERROR_FAILURE; } } nsCOMPtr<nsIPrintingPromptService> pps(do_GetService("@mozilla.org/embedcomp/printingprompt-service;1")); if (!pps) { return NS_ERROR_FAILURE; } // The initSettings we got can be wrapped using // PrintDataUtils' MockWebBrowserPrint, which implements enough of // nsIWebBrowserPrint to keep the dialogs happy. nsCOMPtr<nsIWebBrowserPrint> wbp = new MockWebBrowserPrint(aData); // Use the existing RemotePrintJob and its settings, if we have one, to make // sure they stay current. RemotePrintJobParent* remotePrintJob = static_cast<RemotePrintJobParent*>(aData.remotePrintJobParent()); nsCOMPtr<nsIPrintSettings> settings; nsresult rv; if (remotePrintJob) { settings = remotePrintJob->GetPrintSettings(); } else { rv = mPrintSettingsSvc->GetNewPrintSettings(getter_AddRefs(settings)); NS_ENSURE_SUCCESS(rv, rv); } // We only want to use the print silently setting from the parent. bool printSilently; rv = settings->GetPrintSilent(&printSilently); NS_ENSURE_SUCCESS(rv, rv); rv = mPrintSettingsSvc->DeserializeToPrintSettings(aData, settings); NS_ENSURE_SUCCESS(rv, rv); rv = settings->SetPrintSilent(printSilently); NS_ENSURE_SUCCESS(rv, rv); // If this is for print preview or we are printing silently then we just need // to initialize the print settings with anything specific from the printer. if (isPrintPreview || printSilently || Preferences::GetBool("print.always_print_silent", printSilently)) { nsXPIDLString printerName; rv = settings->GetPrinterName(getter_Copies(printerName)); NS_ENSURE_SUCCESS(rv, rv); settings->SetIsInitializedFromPrinter(false); mPrintSettingsSvc->InitPrintSettingsFromPrinter(printerName, settings); } else { rv = pps->ShowPrintDialog(parentWin, wbp, settings); NS_ENSURE_SUCCESS(rv, rv); } if (isPrintPreview) { // For print preview we don't want a RemotePrintJob just the settings. rv = mPrintSettingsSvc->SerializeToPrintData(settings, nullptr, aResult); } else { rv = SerializeAndEnsureRemotePrintJob(settings, nullptr, remotePrintJob, aResult); } return rv; }
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 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; }