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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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_layers_mlgpu_RenderViewMLGPU_h
#define mozilla_gfx_layers_mlgpu_RenderViewMLGPU_h
#include "LayerManagerMLGPU.h"
#include "ClearRegionHelper.h"
#include "RenderPassMLGPU.h"
#include "Units.h"
#include <deque>
namespace mozilla {
namespace layers {
class FrameBuilder;
class ContainerLayerMLGPU;
class MLGRenderTarget;
class RenderViewMLGPU {
public:
NS_INLINE_DECL_REFCOUNTING(RenderViewMLGPU)
// Constructor for the widget render target.
RenderViewMLGPU(FrameBuilder* aBuilder, MLGRenderTarget* aTarget,
const nsIntRegion& aInvalidRegion);
// Constructor for intermediate surfaces.
RenderViewMLGPU(FrameBuilder* aBuilder, ContainerLayerMLGPU* aContainer,
RenderViewMLGPU* aParent);
void Prepare();
void Render();
void AddChild(RenderViewMLGPU* aParent);
void AddItem(LayerMLGPU* aItem, const gfx::IntRect& aBounds,
Maybe<gfx::Polygon>&& aGeometry);
void FinishBuilding();
const gfx::IntPoint& GetTargetOffset() const { return mTargetOffset; }
RenderViewMLGPU* GetParent() const { return mParent; }
bool HasDepthBuffer() const { return mUseDepthBuffer; }
// Render after having previously delayed rendering due to the view
// requiring a backdrop copy.
void RenderAfterBackdropCopy();
void RestoreDeviceState();
// The size and render target cannot be read until the view has finished
// building, since we try to right-size the render target to the visible
// region.
MLGRenderTarget* GetRenderTarget() const;
gfx::IntSize GetSize() const;
gfx::IntRect GetInvalidRect() const { return mInvalidBounds; }
private:
RenderViewMLGPU(FrameBuilder* aBuilder, RenderViewMLGPU* aParent);
~RenderViewMLGPU();
void ExecuteRendering();
bool UpdateVisibleRegion(ItemInfo& aItem);
void AddItemFrontToBack(LayerMLGPU* aLayer, ItemInfo& aItem);
void AddItemBackToFront(LayerMLGPU* aLayer, ItemInfo& aItem);
void PrepareClears();
void SetDeviceState();
void SetDepthTestMode(MLGDepthTestMode aMode);
void ExecutePass(RenderPassMLGPU* aPass);
// Return the sorting index offset to use.
int32_t PrepareDepthBuffer();
private:
std::deque<RefPtr<RenderPassMLGPU>> mFrontToBack;
std::deque<RefPtr<RenderPassMLGPU>> mBackToFront;
FrameBuilder* mBuilder;
RefPtr<MLGDevice> mDevice;
RenderViewMLGPU* mParent;
std::vector<RefPtr<RenderViewMLGPU>> mChildren;
// Shader data.
ConstantBufferSection mWorldConstants;
// Information for the initial target surface clear. This covers the area that
// won't be occluded by opaque content.
ClearRegionHelper mPreClear;
// The post-clear region, that must be cleared after all drawing is done.
nsIntRegion mPostClearRegion;
ClearRegionHelper mPostClear;
// Either an MLGSwapChain-derived render target, or an intermediate surface.
RefPtr<MLGRenderTarget> mTarget;
// For intermediate render targets only, this is the layer owning the render
// target.
ContainerLayerMLGPU* mContainer;
// The offset adjustment from container layer space to render target space.
// This is 0,0 for the root view.
gfx::IntPoint mTargetOffset;
// The invalid bounds as computed by LayerTreeInvalidation. This is the
// initial render bounds size, if invalidation is disabled.
gfx::IntRect mInvalidBounds;
// The occluded region, which is updated every time we process an opaque,
// rectangular item. This is not actually in LayerPixels, we do this to
// avoid FromUnknownRegion which has array copies.
LayerIntRegion mOccludedRegion;
// True if we've finished adding layers to the view.
bool mFinishedBuilding;
// This state is used to avoid changing buffers while we execute batches.
size_t mCurrentLayerBufferIndex;
size_t mCurrentMaskRectBufferIndex;
// This state is saved locally so it can be restored in RestoreDeviceState.
MLGDepthTestMode mCurrentDepthMode;
// Depth-buffer tracking.
int32_t mNextSortIndex;
bool mUseDepthBuffer;
bool mDepthBufferNeedsClear;
};
} // namespace layers
} // namespace mozilla
#endif // mozilla_gfx_layers_mlgpu_RenderViewMLGPU_h
|
