//---------------------------------------------------------------------------------
// Name: resetGame()
//---------------------------------------------------------------------------------
void GameplayState::resetGame()
{
resetGameState();
memset(m_tdata, 0, sizeof(unsigned) * 4 );
m_map_complete_time = 0;
BATTLE_CITY->resetMap();
BATTLE_CITY->resetPlayers();
// set layers position
GraphicsLayer * tp = LAYER_MGR->findLayer(BOTTOM_LAYER);
GraphicsLayer * bt = LAYER_MGR->findLayer(TOP_LAYER);
assert( tp && bt );
unsigned w, h;
w = MAP_MGR->getMapWidthPx();
h = MAP_MGR->getMapHeightPx();
unsigned x, y;
x = (BASE_SCREEN_WIDTH - w ) >> 1;
y = (BASE_SCREEN_HEIGHT - h ) >> 1;
tp->setPosition( x, y );
bt->setPosition( x, y );
}
void WebInspectorClient::showPaintRect(const FloatRect& rect)
{
if (!m_paintRectOverlay) {
m_paintRectOverlay = PageOverlay::create(this, PageOverlay::OverlayType::Document);
m_page->installPageOverlay(m_paintRectOverlay, PageOverlay::FadeMode::DoNotFade);
}
if (!m_paintIndicatorLayerClient)
m_paintIndicatorLayerClient = std::make_unique<RepaintIndicatorLayerClient>(*this);
std::unique_ptr<GraphicsLayer> paintLayer = GraphicsLayer::create(m_page->drawingArea()->graphicsLayerFactory(), *m_paintIndicatorLayerClient);
paintLayer->setAnchorPoint(FloatPoint3D());
paintLayer->setPosition(rect.location());
paintLayer->setSize(rect.size());
paintLayer->setBackgroundColor(Color(1.0f, 0.0f, 0.0f, 0.2f));
KeyframeValueList fadeKeyframes(AnimatedPropertyOpacity);
OwnPtr<AnimationValue> intialValue = FloatAnimationValue::create(0, 1);
fadeKeyframes.insert(intialValue.release());
OwnPtr<AnimationValue> finalValue = FloatAnimationValue::create(0.25, 0);
fadeKeyframes.insert(finalValue.release());
RefPtr<Animation> opacityAnimation = Animation::create();
opacityAnimation->setDuration(0.25);
paintLayer->addAnimation(fadeKeyframes, FloatSize(), opacityAnimation.get(), ASCIILiteral("opacity"), 0);
m_paintRectLayers.add(paintLayer.get());
GraphicsLayer* overlayRootLayer = m_paintRectOverlay->layer();
overlayRootLayer->addChild(paintLayer.release());
}
void RenderLayerCompositor::removeCompositedChildren(RenderLayer* layer)
{
ASSERT(layer->isComposited());
GraphicsLayer* hostingLayer = layer->backing()->parentForSublayers();
hostingLayer->removeAllChildren();
}
void Internals::setBackgroundBlurOnNode(Node* node, int blurLength, ExceptionCode& ec)
{
if (!node) {
ec = INVALID_ACCESS_ERR;
return;
}
RenderObject* renderObject = node->renderer();
if (!renderObject) {
ec = INVALID_NODE_TYPE_ERR;
return;
}
RenderLayer* renderLayer = renderObject->enclosingLayer();
if (!renderLayer || !renderLayer->isComposited()) {
ec = INVALID_STATE_ERR;
return;
}
GraphicsLayer* graphicsLayer = renderLayer->backing()->graphicsLayer();
if (!graphicsLayer) {
ec = INVALID_NODE_TYPE_ERR;
return;
}
PlatformLayer* platformLayer = graphicsLayer->platformLayer();
if (!platformLayer) {
ec = INVALID_NODE_TYPE_ERR;
return;
}
FilterOperations filters;
filters.operations().append(BlurFilterOperation::create(Length(blurLength, Fixed), FilterOperation::BLUR));
platformLayer->setBackgroundFilters(filters);
}
void LayerTreeRenderer::setAnimatedTransform(uint32_t id, const WebCore::TransformationMatrix& transform)
{
GraphicsLayer* layer = layerByID(id);
ASSERT(layer);
layer->setTransform(transform);
}
void PinchViewports::setupScrollbar(WebScrollbar::Orientation orientation)
{
bool isHorizontal = orientation == WebScrollbar::Horizontal;
GraphicsLayer* scrollbarGraphicsLayer = isHorizontal ?
m_overlayScrollbarHorizontal.get() : m_overlayScrollbarVertical.get();
OwnPtr<WebScrollbarLayer>& webScrollbarLayer = isHorizontal ?
m_webOverlayScrollbarHorizontal : m_webOverlayScrollbarVertical;
const int overlayScrollbarThickness = m_owner->settingsImpl()->pinchOverlayScrollbarThickness();
if (!webScrollbarLayer) {
WebCore::ScrollingCoordinator* coordinator = m_owner->page()->scrollingCoordinator();
ASSERT(coordinator);
WebCore::ScrollbarOrientation webcoreOrientation = isHorizontal ? WebCore::HorizontalScrollbar : WebCore::VerticalScrollbar;
webScrollbarLayer = coordinator->createSolidColorScrollbarLayer(webcoreOrientation, overlayScrollbarThickness, false);
webScrollbarLayer->setScrollLayer(m_innerViewportScrollLayer->platformLayer());
scrollbarGraphicsLayer->setContentsToPlatformLayer(webScrollbarLayer->layer());
scrollbarGraphicsLayer->setDrawsContent(false);
}
int xPosition = isHorizontal ? 0 : m_innerViewportContainerLayer->size().width() - overlayScrollbarThickness;
int yPosition = isHorizontal ? m_innerViewportContainerLayer->size().height() - overlayScrollbarThickness : 0;
int width = isHorizontal ? m_innerViewportContainerLayer->size().width() - overlayScrollbarThickness : overlayScrollbarThickness;
int height = isHorizontal ? overlayScrollbarThickness : m_innerViewportContainerLayer->size().height() - overlayScrollbarThickness;
scrollbarGraphicsLayer->setPosition(WebCore::IntPoint(xPosition, yPosition));
scrollbarGraphicsLayer->setSize(WebCore::IntSize(width, height));
}
void PageOverlayController::updateSettingsForLayer(GraphicsLayer& layer)
{
Settings& settings = m_mainFrame.settings();
layer.setAcceleratesDrawing(settings.acceleratedDrawingEnabled());
layer.setShowDebugBorder(settings.showDebugBorders());
layer.setShowRepaintCounter(settings.showRepaintCounter());
}
void LayerTreeRenderer::setAnimatedOpacity(uint32_t id, float opacity)
{
GraphicsLayer* layer = layerByID(id);
ASSERT(layer);
layer->setOpacity(opacity);
}
void PaintLayerCompositor::applyOverlayFullscreenVideoAdjustmentIfNeeded()
{
m_inOverlayFullscreenVideo = false;
if (!m_rootContentLayer)
return;
bool isLocalRoot = m_layoutView.frame()->isLocalRoot();
LayoutVideo* video = findFullscreenVideoLayoutObject(m_layoutView.document());
if (!video || !video->layer()->hasCompositedLayerMapping() || !video->videoElement()->usesOverlayFullscreenVideo()) {
if (isLocalRoot) {
GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer();
if (backgroundLayer && !backgroundLayer->parent())
rootFixedBackgroundsChanged();
}
return;
}
GraphicsLayer* videoLayer = video->layer()->compositedLayerMapping()->mainGraphicsLayer();
// The fullscreen video has layer position equal to its enclosing frame's scroll position because fullscreen container is fixed-positioned.
// We should reset layer position here since we are going to reattach the layer at the very top level.
videoLayer->setPosition(IntPoint());
// Only steal fullscreen video layer and clear all other layers if we are the main frame.
if (!isLocalRoot)
return;
m_rootContentLayer->removeAllChildren();
m_overflowControlsHostLayer->addChild(videoLayer);
if (GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer())
backgroundLayer->removeFromParent();
m_inOverlayFullscreenVideo = true;
}
void BGI_AirWire::paint(QPainter* painter,
const QStyleOptionGraphicsItem* option,
QWidget* widget) {
Q_UNUSED(widget);
bool highlight =
mAirWire.isSelected() || mAirWire.getNetSignal().isHighlighted();
const qreal lod =
option->levelOfDetailFromTransform(painter->worldTransform());
// draw line
if (mLayer && mLayer->isVisible()) {
qreal width = highlight ? 3 / lod : 0; // highlighted airwires are thicker
QPen pen(mLayer->getColor(highlight), width, Qt::SolidLine, Qt::RoundCap);
painter->setPen(pen);
painter->drawLines(mLines);
if (mLines.count() > 1) {
painter->setBrush(Qt::NoBrush);
painter->drawEllipse(mBoundingRect);
}
}
#ifdef QT_DEBUG
GraphicsLayer* layer =
getLayer(GraphicsLayer::sDebugGraphicsItemsBoundingRects);
Q_ASSERT(layer);
if (layer && layer->isVisible()) {
// draw bounding rect
painter->setPen(QPen(layer->getColor(highlight), 0));
painter->setBrush(Qt::NoBrush);
painter->drawRect(mBoundingRect);
}
#endif
}
void InspectorLayerTreeAgent::buildLayerIdToNodeIdMap(
PaintLayer* root,
LayerIdToNodeIdMap& layerIdToNodeIdMap) {
if (root->hasCompositedLayerMapping()) {
if (Node* node = root->layoutObject()->generatingNode()) {
GraphicsLayer* graphicsLayer =
root->compositedLayerMapping()->childForSuperlayers();
layerIdToNodeIdMap.set(graphicsLayer->platformLayer()->id(),
idForNode(node));
}
}
for (PaintLayer* child = root->firstChild(); child;
child = child->nextSibling())
buildLayerIdToNodeIdMap(child, layerIdToNodeIdMap);
if (!root->layoutObject()->isLayoutIFrame())
return;
FrameView* childFrameView =
toFrameView(toLayoutPart(root->layoutObject())->widget());
LayoutViewItem childLayoutViewItem = childFrameView->layoutViewItem();
if (!childLayoutViewItem.isNull()) {
if (PaintLayerCompositor* childCompositor =
childLayoutViewItem.compositor())
buildLayerIdToNodeIdMap(childCompositor->rootLayer(), layerIdToNodeIdMap);
}
}
void GraphicsLayer::removeAllChildren()
{
while (!m_children.isEmpty()) {
GraphicsLayer* curLayer = m_children.last();
ASSERT(curLayer->parent());
curLayer->removeFromParent();
}
}
void GraphicsLayer::removeAllChildren()
{
while (m_children.size()) {
GraphicsLayer* curLayer = m_children[0];
ASSERT(curLayer->parent());
curLayer->removeFromParent();
}
}
void LayerTreeRenderer::setLayerFilters(CoordinatedLayerID id, const FilterOperations& filters)
{
GraphicsLayer* layer = layerByID(id);
#if ENABLE(CSS_SHADERS)
injectCachedCustomFilterPrograms(filters);
#endif
layer->setFilters(filters);
}
void LayerTreeRenderer::destroyCanvas(CoordinatedLayerID id)
{
ASSERT(m_textureMapper);
GraphicsLayer* layer = layerByID(id);
ASSERT(m_surfaceBackingStores.contains(id));
m_surfaceBackingStores.remove(id);
layer->setContentsToMedia(0);
}
void LayerTreeRenderer::setLayerFilters(WebLayerID id, const FilterOperations& filters)
{
ensureLayer(id);
LayerMap::iterator it = m_layers.find(id);
ASSERT(it != m_layers.end());
GraphicsLayer* layer = it->second;
layer->setFilters(filters);
}
bool GraphicsLayer::hasAncestor(GraphicsLayer* ancestor) const
{
for (GraphicsLayer* curr = parent(); curr; curr = curr->parent()) {
if (curr == ancestor)
return true;
}
return false;
}
void LayerTreeHostGtk::setPageOverlayNeedsDisplay(PageOverlay* pageOverlay, const IntRect& rect)
{
GraphicsLayer* layer = m_pageOverlayLayers.get(pageOverlay);
if (!layer)
return;
layer->setNeedsDisplayInRect(rect);
scheduleLayerFlush();
}
void LayerTreeHostProxy::deleteLayer(WebLayerID layerID)
{
GraphicsLayer* layer = layerByID(layerID);
if (!layer)
return;
layer->removeFromParent();
m_layers.remove(layerID);
delete layer;
}
static void updateOverlayGeometry(PageOverlay& overlay, GraphicsLayer& graphicsLayer)
{
IntRect overlayFrame = overlay.frame();
if (overlayFrame.location() == graphicsLayer.position() && overlayFrame.size() == graphicsLayer.size())
return;
graphicsLayer.setPosition(overlayFrame.location());
graphicsLayer.setSize(overlayFrame.size());
}
TEST_F(ScrollingCoordinatorTest, overflowHidden)
{
registerMockedHttpURLLoad("overflow-hidden.html");
navigateTo(m_baseURL + "overflow-hidden.html");
forceFullCompositingUpdate();
// Verify the properties of the accelerated scrolling element starting from the LayoutObject
// all the way to the WebLayer.
Element* overflowElement = frame()->document()->getElementById("unscrollable-y");
ASSERT(overflowElement);
LayoutObject* layoutObject = overflowElement->layoutObject();
ASSERT_TRUE(layoutObject->isBox());
ASSERT_TRUE(layoutObject->hasLayer());
LayoutBox* box = toLayoutBox(layoutObject);
ASSERT_TRUE(box->usesCompositedScrolling());
ASSERT_EQ(PaintsIntoOwnBacking, box->layer()->compositingState());
CompositedLayerMapping* compositedLayerMapping = box->layer()->compositedLayerMapping();
ASSERT_TRUE(compositedLayerMapping->hasScrollingLayer());
ASSERT(compositedLayerMapping->scrollingContentsLayer());
GraphicsLayer* graphicsLayer = compositedLayerMapping->scrollingContentsLayer();
ASSERT_EQ(box->layer()->scrollableArea(), graphicsLayer->scrollableArea());
WebLayer* webScrollLayer = compositedLayerMapping->scrollingContentsLayer()->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
ASSERT_FALSE(webScrollLayer->userScrollableVertical());
overflowElement = frame()->document()->getElementById("unscrollable-x");
ASSERT(overflowElement);
layoutObject = overflowElement->layoutObject();
ASSERT_TRUE(layoutObject->isBox());
ASSERT_TRUE(layoutObject->hasLayer());
box = toLayoutBox(layoutObject);
ASSERT_TRUE(box->scrollableArea()->usesCompositedScrolling());
ASSERT_EQ(PaintsIntoOwnBacking, box->layer()->compositingState());
compositedLayerMapping = box->layer()->compositedLayerMapping();
ASSERT_TRUE(compositedLayerMapping->hasScrollingLayer());
ASSERT(compositedLayerMapping->scrollingContentsLayer());
graphicsLayer = compositedLayerMapping->scrollingContentsLayer();
ASSERT_EQ(box->layer()->scrollableArea(), graphicsLayer->scrollableArea());
webScrollLayer = compositedLayerMapping->scrollingContentsLayer()->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
ASSERT_FALSE(webScrollLayer->userScrollableHorizontal());
ASSERT_TRUE(webScrollLayer->userScrollableVertical());
}
void LayerTreeRenderer::createCanvas(CoordinatedLayerID id, const WebCore::IntSize&, PassRefPtr<GraphicsSurface> surface)
{
ASSERT(m_textureMapper);
GraphicsLayer* layer = layerByID(id);
ASSERT(!m_surfaceBackingStores.contains(id));
RefPtr<TextureMapperSurfaceBackingStore> canvasBackingStore(TextureMapperSurfaceBackingStore::create());
m_surfaceBackingStores.set(id, canvasBackingStore);
canvasBackingStore->setGraphicsSurface(surface);
layer->setContentsToMedia(canvasBackingStore.get());
}
void RenderLayerCompositor::parentInRootLayer(RenderLayer* layer)
{
ASSERT(layer->isComposited());
GraphicsLayer* layerAnchor = layer->backing()->childForSuperlayers();
if (layerAnchor->parent() != m_rootPlatformLayer) {
layerAnchor->removeFromParent();
if (m_rootPlatformLayer)
m_rootPlatformLayer->addChild(layerAnchor);
}
}
void LayerTreeRenderer::setLayerChildren(CoordinatedLayerID id, const Vector<CoordinatedLayerID>& childIDs)
{
GraphicsLayer* layer = layerByID(id);
Vector<GraphicsLayer*> children;
for (size_t i = 0; i < childIDs.size(); ++i) {
CoordinatedLayerID childID = childIDs[i];
GraphicsLayer* child = layerByID(childID);
children.append(child);
}
layer->setChildren(children);
}
void DevToolsEmulator::resetViewport() {
if (!m_viewportOverride)
return;
bool originalMasking = m_viewportOverride->originalVisualViewportMasking;
m_viewportOverride = WTF::nullopt;
GraphicsLayer* containerLayer =
m_webViewImpl->page()->frameHost().visualViewport().containerLayer();
if (containerLayer)
containerLayer->setMasksToBounds(originalMasking);
updateRootLayerTransform();
}
void WebViewBenchmarkSupportImpl::acceleratedPaintUnclipped(PaintClient* paintClient, GraphicsLayer& layer)
{
FloatSize layerSize = layer.size();
IntRect clip(0, 0, layerSize.width(), layerSize.height());
if (layer.drawsContent())
paintLayer(paintClient, layer, clip);
const Vector<GraphicsLayer*>& children = layer.children();
Vector<GraphicsLayer*>::const_iterator it;
for (it = children.begin(); it != children.end(); ++it)
acceleratedPaintUnclipped(paintClient, **it);
}
void PinchViewports::registerViewportLayersWithTreeView(WebLayerTreeView* layerTreeView) const
{
ASSERT(layerTreeView);
WebCore::RenderLayerCompositor* compositor = m_owner->compositor();
GraphicsLayer* scrollLayer = compositor->scrollLayer();
ASSERT(compositor);
layerTreeView->registerViewportLayers(
m_pageScaleLayer->platformLayer(),
m_innerViewportScrollLayer->platformLayer(),
scrollLayer->platformLayer());
}
void LayerTreeRenderer::deleteLayer(WebLayerID layerID)
{
GraphicsLayer* layer = layerByID(layerID);
if (!layer)
return;
layer->removeFromParent();
m_layers.remove(layerID);
m_fixedLayers.remove(layerID);
#if USE(GRAPHICS_SURFACE)
m_surfaceBackingStores.remove(layerID);
#endif
delete layer;
}
static void paintLayers(PaintLayer& layer, SimDisplayItemList& displayList)
{
if (layer.isAllowedToQueryCompositingState() && layer.compositingState() == PaintsIntoOwnBacking) {
CompositedLayerMapping* mapping = layer.compositedLayerMapping();
GraphicsLayer* graphicsLayer = mapping->mainGraphicsLayer();
if (graphicsLayer->hasTrackedPaintInvalidations()) {
ContentLayerDelegate* delegate = graphicsLayer->contentLayerDelegateForTesting();
delegate->paintContents(&displayList, WebRect(0, 0, layer.size().width(), layer.size().height()));
graphicsLayer->resetTrackedPaintInvalidations();
}
}
for (PaintLayer* child = layer.firstChild(); child; child = child->nextSibling())
paintLayers(*child, displayList);
}
void InspectorLayerTreeAgent::makeSnapshot(ErrorString* errorString, const String& layerId, String* snapshotId)
{
GraphicsLayer* layer = layerById(errorString, layerId);
if (!layer)
return;
GraphicsContextRecorder recorder;
IntSize size = expandedIntSize(layer->size());
GraphicsContext* context = recorder.record(size, layer->contentsOpaque());
layer->paint(*context, IntRect(IntPoint(0, 0), size));
RefPtr<GraphicsContextSnapshot> snapshot = recorder.stop();
*snapshotId = String::number(++s_lastSnapshotId);
bool newEntry = m_snapshotById.add(*snapshotId, snapshot).isNewEntry;
ASSERT_UNUSED(newEntry, newEntry);
}
