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
163
164
165
166
167
168
169
170
171
172
173
|
// Copyright 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_VIZ_COMMON_QUADS_RENDER_PASS_H_
#define COMPONENTS_VIZ_COMMON_QUADS_RENDER_PASS_H_
#include <stddef.h>
#include <utility>
#include <vector>
#include "base/callback.h"
#include "base/hash.h"
#include "base/macros.h"
#include "cc/base/list_container.h"
#include "cc/paint/filter_operations.h"
#include "components/viz/common/quads/draw_quad.h"
#include "components/viz/common/quads/largest_draw_quad.h"
#include "components/viz/common/viz_common_export.h"
#include "ui/gfx/color_space.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/transform.h"
namespace base {
namespace trace_event {
class TracedValue;
}
} // namespace base
namespace viz {
class CopyOutputRequest;
class DrawQuad;
class RenderPassDrawQuad;
class SharedQuadState;
// A list of DrawQuad objects, sorted internally in front-to-back order. To
// add a new quad drawn behind another quad, it must be placed after the other
// quad.
class VIZ_COMMON_EXPORT QuadList : public cc::ListContainer<DrawQuad> {
public:
QuadList();
explicit QuadList(size_t default_size_to_reserve);
typedef QuadList::ReverseIterator BackToFrontIterator;
typedef QuadList::ConstReverseIterator ConstBackToFrontIterator;
inline BackToFrontIterator BackToFrontBegin() { return rbegin(); }
inline BackToFrontIterator BackToFrontEnd() { return rend(); }
inline ConstBackToFrontIterator BackToFrontBegin() const { return rbegin(); }
inline ConstBackToFrontIterator BackToFrontEnd() const { return rend(); }
// This function is used by overlay algorithm to fill the backbuffer with
// transparent black.
void ReplaceExistingQuadWithOpaqueTransparentSolidColor(Iterator at);
};
using SharedQuadStateList = cc::ListContainer<SharedQuadState>;
using RenderPassId = uint64_t;
class VIZ_COMMON_EXPORT RenderPass {
public:
~RenderPass();
static std::unique_ptr<RenderPass> Create();
static std::unique_ptr<RenderPass> Create(size_t num_layers);
static std::unique_ptr<RenderPass> Create(size_t shared_quad_state_list_size,
size_t quad_list_size);
// A shallow copy of the render pass, which does not include its quads or copy
// requests.
std::unique_ptr<RenderPass> Copy(int new_id) const;
// A deep copy of the render pass that includes quads.
std::unique_ptr<RenderPass> DeepCopy() const;
// A deep copy of the render passes in the list including the quads.
static void CopyAll(const std::vector<std::unique_ptr<RenderPass>>& in,
std::vector<std::unique_ptr<RenderPass>>* out);
void SetNew(RenderPassId id,
const gfx::Rect& output_rect,
const gfx::Rect& damage_rect,
const gfx::Transform& transform_to_root_target);
void SetAll(RenderPassId id,
const gfx::Rect& output_rect,
const gfx::Rect& damage_rect,
const gfx::Transform& transform_to_root_target,
const cc::FilterOperations& filters,
const cc::FilterOperations& background_filters,
const gfx::ColorSpace& color_space,
bool has_transparent_background,
bool cache_render_pass,
bool has_damage_from_contributing_content,
bool generate_mipmap);
void AsValueInto(base::trace_event::TracedValue* dict) const;
SharedQuadState* CreateAndAppendSharedQuadState();
template <typename DrawQuadType>
DrawQuadType* CreateAndAppendDrawQuad() {
return quad_list.AllocateAndConstruct<DrawQuadType>();
}
RenderPassDrawQuad* CopyFromAndAppendRenderPassDrawQuad(
const RenderPassDrawQuad* quad,
RenderPassId render_pass_id);
DrawQuad* CopyFromAndAppendDrawQuad(const DrawQuad* quad);
// Uniquely identifies the render pass in the compositor's current frame.
RenderPassId id = 0;
// These are in the space of the render pass' physical pixels.
gfx::Rect output_rect;
gfx::Rect damage_rect;
// Transforms from the origin of the |output_rect| to the origin of the root
// render pass' |output_rect|.
gfx::Transform transform_to_root_target;
// Post-processing filters, applied to the pixels in the render pass' texture.
cc::FilterOperations filters;
// Post-processing filters, applied to the pixels showing through the
// background of the render pass, from behind it.
cc::FilterOperations background_filters;
// The color space into which content will be rendered for this render pass.
gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB();
// If false, the pixels in the render pass' texture are all opaque.
bool has_transparent_background = true;
// If true we might reuse the texture if there is no damage.
bool cache_render_pass = false;
// Indicates whether there is accumulated damage from contributing render
// surface or layer or surface quad. Not including property changes on itself.
bool has_damage_from_contributing_content = false;
// Generate mipmap for trilinear filtering, applied to render pass' texture.
bool generate_mipmap = false;
// If non-empty, the renderer should produce a copy of the render pass'
// contents as a bitmap, and give a copy of the bitmap to each callback in
// this list.
std::vector<std::unique_ptr<CopyOutputRequest>> copy_requests;
QuadList quad_list;
SharedQuadStateList shared_quad_state_list;
protected:
explicit RenderPass(size_t num_layers);
RenderPass();
RenderPass(size_t shared_quad_state_list_size, size_t quad_list_size);
private:
template <typename DrawQuadType>
DrawQuadType* CopyFromAndAppendTypedDrawQuad(const DrawQuad* quad) {
return quad_list.AllocateAndCopyFrom(DrawQuadType::MaterialCast(quad));
}
DISALLOW_COPY_AND_ASSIGN(RenderPass);
};
using RenderPassList = std::vector<std::unique_ptr<RenderPass>>;
} // namespace viz
#endif // COMPONENTS_VIZ_COMMON_QUADS_RENDER_PASS_H_
|
