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