Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
       2             : * This Source Code Form is subject to the terms of the Mozilla Public
       3             : * License, v. 2.0. If a copy of the MPL was not distributed with this
       4             : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       5             : 
       6             : #ifndef MOZILLA_GFX_LAYERMANAGERMLGPU_H
       7             : #define MOZILLA_GFX_LAYERMANAGERMLGPU_H
       8             : 
       9             : #include "Layers.h"
      10             : #include "mozilla/layers/LayerManagerComposite.h"
      11             : #include "LayerMLGPU.h"
      12             : 
      13             : namespace mozilla {
      14             : namespace layers {
      15             : 
      16             : class FrameBuilder;
      17             : class LayerManagerMLGPU;
      18             : class RenderPassMLGPU;
      19             : class SharedBufferMLGPU;
      20             : class RenderViewMLGPU;
      21             : class TextRenderer;
      22             : class TextureSourceProviderMLGPU;
      23             : class MLGBuffer;
      24             : class MLGDevice;
      25             : class MLGSwapChain;
      26             : class MLGTileBuffer;
      27             : struct LayerProperties;
      28             : 
      29             : class LayerManagerMLGPU final : public HostLayerManager
      30             : {
      31             : public:
      32             :   explicit LayerManagerMLGPU(widget::CompositorWidget* aWidget);
      33             :   ~LayerManagerMLGPU();
      34             : 
      35             :   bool Initialize();
      36             :   void Destroy() override;
      37             : 
      38             :   // LayerManager methods
      39             :   bool BeginTransaction() override;
      40             :   void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget, const gfx::IntRect& aRect) override;
      41             :   void SetRoot(Layer* aLayer) override;
      42             :   already_AddRefed<PaintedLayer> CreatePaintedLayer() override;
      43             :   already_AddRefed<ContainerLayer> CreateContainerLayer() override;
      44             :   already_AddRefed<ImageLayer> CreateImageLayer() override;
      45             :   already_AddRefed<ColorLayer> CreateColorLayer() override;
      46             :   already_AddRefed<TextLayer> CreateTextLayer() override;
      47             :   already_AddRefed<CanvasLayer> CreateCanvasLayer() override;
      48             :   already_AddRefed<RefLayer> CreateRefLayer() override;
      49             :   already_AddRefed<BorderLayer> CreateBorderLayer() override;
      50             : 
      51             :   bool AreComponentAlphaLayersEnabled() override;
      52             :   bool BlendingRequiresIntermediateSurface() override;
      53             :   bool SupportsBackdropCopyForComponentAlpha() override;
      54             : 
      55             :   // HostLayerManager methods
      56             :   void ForcePresent() override;
      57             :   TextureFactoryIdentifier GetTextureFactoryIdentifier() override;
      58             :   LayersBackend GetBackendType() override;
      59             :   void AddInvalidRegion(const nsIntRegion& aRegion) override;
      60           0 :   void ClearApproximatelyVisibleRegions(uint64_t aLayersId,
      61           0 :                                                 const Maybe<uint32_t>& aPresShellId) override {}
      62           0 :   void UpdateApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
      63           0 :                                                 const CSSIntRegion& aRegion) override {}
      64             :   void EndTransaction(const TimeStamp& aTimeStamp, EndTransactionFlags aFlags) override;
      65             :   void EndTransaction(DrawPaintedLayerCallback aCallback,
      66             :                       void* aCallbackData,
      67             :                       EndTransactionFlags aFlags) override;
      68           0 :   Compositor* GetCompositor() const override {
      69           0 :     return nullptr;
      70             :   }
      71             :   bool IsCompositingToScreen() const override;
      72             :   TextureSourceProvider* GetTextureSourceProvider() const override;
      73             :   void ClearCachedResources(Layer* aSubtree = nullptr) override;
      74             :   void NotifyShadowTreeTransaction() override;
      75             :   void UpdateRenderBounds(const gfx::IntRect& aRect) override;
      76             : 
      77           0 :   LayerManagerMLGPU* AsLayerManagerMLGPU() override {
      78           0 :     return this;
      79             :   }
      80           0 :   const char* Name() const override {
      81           0 :     return "";
      82             :   }
      83             : 
      84             :   // This should only be called while a FrameBuilder is live.
      85             :   FrameBuilder* GetCurrentFrame() const {
      86             :     MOZ_ASSERT(mCurrentFrame);
      87             :     return mCurrentFrame;
      88             :   }
      89           0 :   MLGDevice* GetDevice() {
      90           0 :     return mDevice;
      91             :   }
      92             : 
      93           0 :   TimeStamp GetLastCompositionEndTime() const {
      94           0 :     return mLastCompositionEndTime;
      95             :   }
      96           0 :   const nsIntRegion& GetRegionToClear() const {
      97           0 :     return mRegionToClear;
      98             :   }
      99             : 
     100             : private:
     101             :   void Composite();
     102             :   void ComputeInvalidRegion();
     103             :   void RenderLayers();
     104             :   void DrawDebugOverlay();
     105             :   bool PreRender();
     106             :   void PostRender();
     107             : 
     108             : private:
     109             :   RefPtr<MLGDevice> mDevice;
     110             :   RefPtr<MLGSwapChain> mSwapChain;
     111             :   RefPtr<TextureSourceProviderMLGPU> mTextureSourceProvider;
     112             :   RefPtr<TextRenderer> mTextRenderer;
     113             :   widget::CompositorWidget* mWidget;
     114             : 
     115             :   UniquePtr<LayerProperties> mClonedLayerTreeProperties;
     116             :   nsIntRegion mNextFrameInvalidRegion;
     117             :   gfx::IntRect mRenderBounds;
     118             : 
     119             :   // These are per-frame only.
     120             :   bool mDrawDiagnostics;
     121             :   bool mUsingInvalidation;
     122             :   nsIntRegion mInvalidRegion;
     123             :   Maybe<widget::WidgetRenderingContext> mWidgetContext;
     124             :   
     125             :   IntSize mWindowSize;
     126             :   TimeStamp mCompositionStartTime;
     127             :   TimeStamp mLastCompositionEndTime;
     128             : 
     129             :   RefPtr<DrawTarget> mTarget;
     130             :   gfx::IntRect mTargetRect;
     131             :   FrameBuilder* mCurrentFrame;
     132             : 
     133             :   RefPtr<MLGBuffer> mDiagnosticVertices;
     134             : };
     135             : 
     136             : } // namespace layers
     137             : } // namespace mozilla
     138             : 
     139             : #endif