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