1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef MOZILLA_GFX_BASICCOMPOSITOR_H
#define MOZILLA_GFX_BASICCOMPOSITOR_H
#include "mozilla/layers/Compositor.h"
#include "mozilla/layers/TextureHost.h"
#include "mozilla/gfx/2D.h"
namespace mozilla {
namespace layers {
class BasicCompositingRenderTarget : public CompositingRenderTarget
{
public:
BasicCompositingRenderTarget(gfx::DrawTarget* aDrawTarget, const gfx::IntRect& aRect)
: CompositingRenderTarget(aRect.TopLeft())
, mDrawTarget(aDrawTarget)
, mSize(aRect.Size())
{ }
virtual const char* Name() const override { return "BasicCompositingRenderTarget"; }
virtual gfx::IntSize GetSize() const override { return mSize; }
void BindRenderTarget();
virtual gfx::SurfaceFormat GetFormat() const override
{
return mDrawTarget ? mDrawTarget->GetFormat()
: gfx::SurfaceFormat(gfx::SurfaceFormat::UNKNOWN);
}
RefPtr<gfx::DrawTarget> mDrawTarget;
gfx::IntSize mSize;
};
class BasicCompositor : public Compositor
{
public:
explicit BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget);
protected:
virtual ~BasicCompositor();
public:
virtual BasicCompositor* AsBasicCompositor() override { return this; }
virtual bool Initialize(nsCString* const out_failureReason) override;
virtual void DetachWidget() override;
virtual TextureFactoryIdentifier GetTextureFactoryIdentifier() override;
virtual already_AddRefed<CompositingRenderTarget>
CreateRenderTarget(const gfx::IntRect &aRect, SurfaceInitMode aInit) override;
virtual already_AddRefed<CompositingRenderTarget>
CreateRenderTargetFromSource(const gfx::IntRect &aRect,
const CompositingRenderTarget *aSource,
const gfx::IntPoint &aSourcePoint) override;
virtual already_AddRefed<CompositingRenderTarget>
CreateRenderTargetForWindow(const LayoutDeviceIntRect& aRect,
const LayoutDeviceIntRect& aClearRect,
BufferMode aBufferMode);
virtual already_AddRefed<DataTextureSource>
CreateDataTextureSource(TextureFlags aFlags = TextureFlags::NO_FLAGS) override;
virtual already_AddRefed<DataTextureSource>
CreateDataTextureSourceAround(gfx::DataSourceSurface* aSurface) override;
virtual already_AddRefed<DataTextureSource>
CreateDataTextureSourceAroundYCbCr(TextureHost* aTexture) override;
virtual bool SupportsEffect(EffectTypes aEffect) override;
virtual void SetRenderTarget(CompositingRenderTarget *aSource) override
{
mRenderTarget = static_cast<BasicCompositingRenderTarget*>(aSource);
mRenderTarget->BindRenderTarget();
}
virtual CompositingRenderTarget* GetCurrentRenderTarget() const override
{
return mRenderTarget;
}
virtual void DrawQuad(const gfx::Rect& aRect,
const gfx::IntRect& aClipRect,
const EffectChain &aEffectChain,
gfx::Float aOpacity,
const gfx::Matrix4x4& aTransform,
const gfx::Rect& aVisibleRect) override;
virtual void ClearRect(const gfx::Rect& aRect) override;
virtual void BeginFrame(const nsIntRegion& aInvalidRegion,
const gfx::IntRect *aClipRectIn,
const gfx::IntRect& aRenderBounds,
const nsIntRegion& aOpaqueRegion,
gfx::IntRect *aClipRectOut = nullptr,
gfx::IntRect *aRenderBoundsOut = nullptr) override;
virtual void EndFrame() override;
virtual void EndFrameForExternalComposition(const gfx::Matrix& aTransform) override;
virtual bool SupportsPartialTextureUpdate() override { return true; }
virtual bool CanUseCanvasLayerForSize(const gfx::IntSize &aSize) override { return true; }
virtual int32_t GetMaxTextureSize() const override;
virtual void SetDestinationSurfaceSize(const gfx::IntSize& aSize) override { }
virtual void SetScreenRenderOffset(const ScreenPoint& aOffset) override {
}
virtual void MakeCurrent(MakeCurrentFlags aFlags = 0) override { }
#ifdef MOZ_DUMP_PAINTING
virtual const char* Name() const override { return "Basic"; }
#endif // MOZ_DUMP_PAINTING
virtual LayersBackend GetBackendType() const override {
return LayersBackend::LAYERS_BASIC;
}
gfx::DrawTarget *GetDrawTarget() { return mDrawTarget; }
virtual bool IsPendingComposite() override
{
return mIsPendingEndRemoteDrawing;
}
virtual void FinishPendingComposite() override;
private:
void TryToEndRemoteDrawing(bool aForceToEnd = false);
bool NeedsToDeferEndRemoteDrawing();
// The final destination surface
RefPtr<gfx::DrawTarget> mDrawTarget;
// The current render target for drawing
RefPtr<BasicCompositingRenderTarget> mRenderTarget;
LayoutDeviceIntRect mInvalidRect;
LayoutDeviceIntRegion mInvalidRegion;
bool mDidExternalComposition;
uint32_t mMaxTextureSize;
bool mIsPendingEndRemoteDrawing;
};
BasicCompositor* AssertBasicCompositor(Compositor* aCompositor);
} // namespace layers
} // namespace mozilla
#endif /* MOZILLA_GFX_BASICCOMPOSITOR_H */
|
