void OfflineAudioContext::fireCompletionEvent()
{
ASSERT(isMainThread());
// We set the state to closed here so that the oncomplete event handler sees
// that the context has been closed.
setContextState(Closed);
AudioBuffer* renderedBuffer = renderTarget();
ASSERT(renderedBuffer);
if (!renderedBuffer)
return;
// Avoid firing the event if the document has already gone away.
if (executionContext()) {
// Call the offline rendering completion event listener and resolve the
// promise too.
dispatchEvent(OfflineAudioCompletionEvent::create(renderedBuffer));
m_completeResolver->resolve(renderedBuffer);
} else {
// The resolver should be rejected when the execution context is gone.
m_completeResolver->reject(DOMException::create(InvalidStateError,
"the execution context does not exist"));
}
}
RenderTarget YouAreDeadDisplay::GetRenderTarget() const
{
static const float kKeyFrame0 = 0.0f;
static const float kKeyFrame1 = 0.5f;
static const float kKeyFrame2 = 1.5f;
static const float kKeyFrame3 = 2.0f;
RenderTarget renderTarget(kMessage.size(), 1);
if ( gIsBetween(mElapsedTime, kKeyFrame0, kKeyFrame1) )
{
// Do nothing
}
else if ( gIsBetween(mElapsedTime, kKeyFrame1, kKeyFrame2) )
{
float t = gFraction(mElapsedTime, kKeyFrame1, kKeyFrame2);
size_t lettersToShow = (size_t) gLerp2D(t, 0.0f, (float) kMessage.size());
renderTarget.Write(kMessage.substr(0, lettersToShow), ETextWhite, 0, 0);
}
else// if ( mElapsedTime >= kKeyFrame2 )
{
renderTarget.Write(kMessage, ETextWhite, 0, 0);
}
return renderTarget;
}
int main()
{
sf::RenderWindow app(sf::VideoMode(WIDTH, HEIGHT), "Raytracer");
BasicTracer tracer;
BasicScene scene(&tracer);
SfmlRenderTarget renderTarget(WIDTH, HEIGHT);
PerspectiveCamera perspectiveCamera(Vector3D(0.0, 50.0, 0.0), Vector3D(0.0, 20.0, 100.0), Vector3D(0.0, -1.0, 0.0));
buildAndRenderScene(scene, perspectiveCamera, renderTarget);
while (app.isOpen())
{
sf::Event Event;
while (app.pollEvent(Event))
{
if (Event.type == sf::Event::Closed)
app.close();
}
app.clear();
app.draw(renderTarget);
app.display();
}
return (0);
}
void CCDelegatedRendererLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData)
{
if (m_renderPassesInDrawOrder.isEmpty())
return;
CCRenderPass::Id targetRenderPassId = appendQuadsData.renderPassId;
// If the index of the renderPassId is 0, then it is a renderPass generated for a layer
// in this compositor, not the delegated renderer. Then we want to merge our root renderPass with
// the target renderPass. Otherwise, it is some renderPass which we added from the delegated
// renderer.
bool shouldMergeRootRenderPassWithTarget = !targetRenderPassId.index;
if (shouldMergeRootRenderPassWithTarget) {
// Verify that the renderPass we are appending to is created our renderTarget.
ASSERT(targetRenderPassId.layerId == renderTarget()->id());
CCRenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.last();
appendRenderPassQuads(quadSink, appendQuadsData, rootDelegatedRenderPass);
} else {
// Verify that the renderPass we are appending to was created by us.
ASSERT(targetRenderPassId.layerId == id());
int renderPassIndex = idToIndex(targetRenderPassId.index);
CCRenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex];
appendRenderPassQuads(quadSink, appendQuadsData, delegatedRenderPass);
}
}
void VideoRendererItem::prepare(QSGGeometryNode *node) {
Q_ASSERT(d->shader);
if (d->take) {
auto image = renderTarget().toImage();
if (!image.isNull())
d->mposd->drawOn(image);
emit frameImageObtained(image);
d->take = false;
}
if (!d->queue.isEmpty()) {
auto &frame = d->queue.front();
if (!frame.format().isEmpty()) {
d->ptsOut = frame.pts();
d->render = true;
d->frameSize = frame.format().size();
if (_Change(d->displaySize, frame.format().displaySize()))
d->updateGeometry(true);
d->shader->upload(frame);
d->direct = d->shader->directRendering();
++d->drawnFrames;
}
d->queue.pop_front();
if (!d->queue.isEmpty()) {
if (d->queue.size() > 3) {
emit droppedFramesChanged(d->dropped += d->queue.size());
d->queue.clear();
} else {
if (d->queue.size() > 1) {
d->queue.pop_front();
emit droppedFramesChanged(++d->dropped);
}
update();
}
}
}
if (d->render && !d->frameSize.isEmpty()) {
if (d->rerender)
d->shader->reupload();
if (d->direct) {
setRenderTarget(d->shader->renderTarget());
} else {
if (!d->fbo || d->fbo->size() != d->frameSize) {
_Renew(d->fbo, d->frameSize, OpenGLCompat::framebufferObjectTextureFormat());
Q_ASSERT(d->fbo->isValid());
}
setRenderTarget(d->fbo->texture());
d->fbo->bind();
d->shader->render(d->kernel);
d->fbo->release();
}
node->markDirty(QSGNode::DirtyMaterial);
}
d->rerender = d->render = false;
LOG_GL_ERROR_Q
}
void FakeTiledLayerChromium::setTexturePriorities(const CCPriorityCalculator& calculator)
{
// Ensure there is always a target render surface available. If none has been
// set (the layer is an orphan for the test), then just set a surface on itself.
bool missingTargetRenderSurface = !renderTarget();
if (missingTargetRenderSurface)
createRenderSurface();
TiledLayerChromium::setTexturePriorities(calculator);
if (missingTargetRenderSurface) {
clearRenderSurface();
setRenderTarget(0);
}
}
RenderTarget StartMenuState::GetRenderTarget() const
{
RenderTarget renderTarget(20, gElemCount(kOptions));
for (size_t i = 0; i < gElemCount(kOptions); ++i)
{
std::string str;
str += (i == mHighlightedMenuOption) ? 26 : ' ';
str += " ";
str += kOptions[i].mDisplayText;
renderTarget.Write(str, ETextWhite, 0, i);
}
return renderTarget;
}
void CCDelegatedRendererLayerImpl::appendRenderPassQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData, CCRenderPass* delegatedRenderPass) const
{
const CCSharedQuadState* currentSharedQuadState = 0;
CCSharedQuadState* copiedSharedQuadState = 0;
for (size_t i = 0; i < delegatedRenderPass->quadList().size(); ++i) {
CCDrawQuad* quad = delegatedRenderPass->quadList()[i];
if (quad->sharedQuadState() != currentSharedQuadState) {
currentSharedQuadState = quad->sharedQuadState();
copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->copy());
}
ASSERT(copiedSharedQuadState);
bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id();
if (!targetIsFromDelegatedRendererLayer) {
// Should be the root render pass.
ASSERT(delegatedRenderPass == m_renderPassesInDrawOrder.last());
// This layer must be drawing to a renderTarget other than itself.
ASSERT(renderTarget() != this);
copiedSharedQuadState->quadTransform = copiedSharedQuadState->quadTransform * drawTransform();
copiedSharedQuadState->opacity *= drawOpacity();
}
scoped_ptr<CCDrawQuad> copyQuad;
if (quad->material() != CCDrawQuad::RenderPass)
copyQuad = quad->copy(copiedSharedQuadState);
else {
CCRenderPass::Id contributingDelegatedRenderPassId = CCRenderPassDrawQuad::materialCast(quad)->renderPassId();
CCRenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId);
ASSERT(contributingRenderPassId != appendQuadsData.renderPassId);
copyQuad = CCRenderPassDrawQuad::materialCast(quad)->copy(copiedSharedQuadState, contributingRenderPassId).PassAs<CCDrawQuad>();
}
ASSERT(copyQuad.get());
quadSink.append(copyQuad.Pass(), appendQuadsData);
}
}
void rasterize(std::ostream &output, const OsmAnd::EyePiece::Configuration& cfg)
#endif
{
// Obtain and configure rasterization style context
OsmAnd::MapStyles stylesCollection;
for(auto itStyleFile = cfg.styleFiles.begin(); itStyleFile != cfg.styleFiles.end(); ++itStyleFile)
{
const auto& styleFile = *itStyleFile;
if(!stylesCollection.registerStyle(styleFile.absoluteFilePath()))
output << xT("Failed to parse metadata of '") << QStringToStlString(styleFile.fileName()) << xT("' or duplicate style") << std::endl;
}
std::shared_ptr<const OsmAnd::MapStyle> style;
if(!stylesCollection.obtainStyle(cfg.styleName, style))
{
output << xT("Failed to resolve style '") << QStringToStlString(cfg.styleName) << xT("'") << std::endl;
return;
}
if(cfg.dumpRules)
style->dump();
OsmAnd::ObfsCollection obfsCollection;
obfsCollection.watchDirectory(cfg.obfsDir);
// Collect all map objects (this should be replaced by something like RasterizerViewport/RasterizerContext)
QList< std::shared_ptr<const OsmAnd::Model::MapObject> > mapObjects;
OsmAnd::AreaI bbox31(
OsmAnd::Utilities::get31TileNumberY(cfg.bbox.top),
OsmAnd::Utilities::get31TileNumberX(cfg.bbox.left),
OsmAnd::Utilities::get31TileNumberY(cfg.bbox.bottom),
OsmAnd::Utilities::get31TileNumberX(cfg.bbox.right)
);
const auto& obfDI = obfsCollection.obtainDataInterface();
OsmAnd::MapFoundationType mapFoundation;
obfDI->obtainMapObjects(&mapObjects, &mapFoundation, bbox31, cfg.zoom, nullptr);
bool basemapAvailable;
obfDI->obtainBasemapPresenceFlag(basemapAvailable);
// Calculate output size in pixels
const auto tileWidth = OsmAnd::Utilities::getTileNumberX(cfg.zoom, cfg.bbox.right) - OsmAnd::Utilities::getTileNumberX(cfg.zoom, cfg.bbox.left);
const auto tileHeight = OsmAnd::Utilities::getTileNumberY(cfg.zoom, cfg.bbox.bottom) - OsmAnd::Utilities::getTileNumberY(cfg.zoom, cfg.bbox.top);
const auto pixelWidth = qCeil(tileWidth * cfg.tileSide);
const auto pixelHeight = qCeil(tileHeight * cfg.tileSide);
output << xT("Will rasterize ") << mapObjects.count() << xT(" objects onto ") << pixelWidth << xT("x") << pixelHeight << xT(" bitmap") << std::endl;
// Allocate render target
SkBitmap renderSurface;
renderSurface.setConfig(cfg.is32bit ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config, pixelWidth, pixelHeight);
if(!renderSurface.allocPixels())
{
output << xT("Failed to allocated render target ") << pixelWidth << xT("x") << pixelHeight;
return;
}
SkDevice renderTarget(renderSurface);
// Create render canvas
SkCanvas canvas(&renderTarget);
// Perform actual rendering
OsmAnd::RasterizerEnvironment rasterizerEnv(style, basemapAvailable);
OsmAnd::RasterizerContext rasterizerContext;
OsmAnd::Rasterizer::prepareContext(rasterizerEnv, rasterizerContext, bbox31, cfg.zoom, cfg.tileSide, cfg.densityFactor, mapFoundation, mapObjects, OsmAnd::PointF(), nullptr);
if(cfg.drawMap)
OsmAnd::Rasterizer::rasterizeMap(rasterizerEnv, rasterizerContext, true, canvas, nullptr);
/*if(cfg.drawText)
OsmAnd::Rasterizer::rasterizeText(rasterizerContext, !cfg.drawMap, canvas, nullptr);*/
// Save rendered area
if(!cfg.output.isEmpty())
{
std::unique_ptr<SkImageEncoder> encoder(CreatePNGImageEncoder());
std::unique_ptr<SkImageEncoder> outputStream(CreatePNGImageEncoder());
encoder->encodeFile(cfg.output.toLocal8Bit(), renderSurface, 100);
}
return;
}
