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
|
// Copyright 2012 The Chromium Authors
// 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_DRAW_QUAD_H_
#define COMPONENTS_VIZ_COMMON_QUADS_DRAW_QUAD_H_
#include <stddef.h>
#include "base/functional/callback.h"
#include "base/memory/raw_ptr_exclusion.h"
#include "components/viz/common/quads/shared_quad_state.h"
#include "components/viz/common/resources/resource_id.h"
#include "components/viz/common/viz_common_export.h"
namespace base {
namespace trace_event {
class TracedValue;
}
} // namespace base
namespace viz {
// DrawQuad is a bag of data used for drawing a quad. Because different
// materials need different bits of per-quad data to render, classes that derive
// from DrawQuad store additional data in their derived instance. The Material
// enum is used to "safely" downcast to the derived class.
// Note: quads contain rects and sizes, which live in different spaces. There is
// the "content space", which is the arbitrary space in which the quad's
// geometry is defined (generally related to the layer that produced the quad,
// e.g. the geometry space for PictureLayerImpls or the layer's coordinate space
// for most other layers). There is also the "target space", which is the space,
// in "physical" pixels, of the render target where the quads is drawn. The
// quad's transform maps the content space to the target space.
class VIZ_COMMON_EXPORT DrawQuad {
public:
enum class Material {
kInvalid = 0,
kDebugBorder = 1,
kPictureContent = 2,
// This is the compositor, pre-aggregation, draw quad.
kCompositorRenderPass = 3,
// This is the viz, post-aggregation, draw quad.
kAggregatedRenderPass = 4,
kSolidColor = 5,
kSharedElement = 6,
// kStreamVideoContent = 7, // Removed. Replaced with kTextureContent.
kSurfaceContent = 8,
kTextureContent = 9,
kTiledContent = 10,
// kYuvVideoContent = 11, // Removed. kTextureContent used instead.
kVideoHole = 12,
kMaxValue = kVideoHole
};
DrawQuad(const DrawQuad& other);
virtual ~DrawQuad();
Material material;
// This rect, after applying the quad_transform(), gives the geometry that
// this quad should draw to. This rect lives in content space.
gfx::Rect rect;
// Allows changing the rect that gets drawn to make it smaller. This value
// should be clipped to |rect|. This rect lives in content space.
gfx::Rect visible_rect;
// By default blending is used when some part of the quad is not opaque.
// With this setting, it is possible to force blending on regardless of the
// opaque area.
bool needs_blending;
// Stores state common to a large bundle of quads; kept separate for memory
// efficiency. There is special treatment to reconstruct these pointers
// during serialization.
// RAW_PTR_EXCLUSION: Performance reasons (rendering.mobile,
// Graphics.Smoothness, see crbug.com/345298647)
RAW_PTR_EXCLUSION const SharedQuadState* shared_quad_state;
// A resource defined by `TransferableResource` with the same `ResourceId`. If
// set to `kInvalidResourceId` then the quad is resourceless.
ResourceId resource_id = kInvalidResourceId;
bool IsDebugQuad() const { return material == Material::kDebugBorder; }
bool ShouldDrawWithBlendingForReasonOtherThanMaskFilter() const {
return needs_blending || shared_quad_state->opacity < 1.0f ||
shared_quad_state->blend_mode != SkBlendMode::kSrcOver;
}
bool ShouldDrawWithBlending() const {
return ShouldDrawWithBlendingForReasonOtherThanMaskFilter() ||
!shared_quad_state->mask_filter_info.IsEmpty();
}
// Is the left edge of this tile aligned with the originating layer's
// left edge?
bool IsLeftEdge() const {
return rect.x() == shared_quad_state->quad_layer_rect.x();
}
// Is the top edge of this tile aligned with the originating layer's
// top edge?
bool IsTopEdge() const {
return rect.y() == shared_quad_state->quad_layer_rect.y();
}
// Is the right edge of this tile aligned with the originating layer's
// right edge?
bool IsRightEdge() const {
return rect.right() == shared_quad_state->quad_layer_rect.right();
}
// Is the bottom edge of this tile aligned with the originating layer's
// bottom edge?
bool IsBottomEdge() const {
return rect.bottom() == shared_quad_state->quad_layer_rect.bottom();
}
// Is any edge of this tile aligned with the originating layer's
// corresponding edge?
bool IsEdge() const {
return IsLeftEdge() || IsTopEdge() || IsRightEdge() || IsBottomEdge();
}
void AsValueInto(base::trace_event::TracedValue* value) const;
template <typename T>
const T* DynamicCast() const {
return this->material == T::kMaterial ? static_cast<const T*>(this)
: nullptr;
}
protected:
DrawQuad();
void SetAll(const SharedQuadState* quad_state,
Material m,
const gfx::Rect& r,
const gfx::Rect& visible_r,
bool blending);
virtual void ExtendValue(base::trace_event::TracedValue* value) const = 0;
};
} // namespace viz
#endif // COMPONENTS_VIZ_COMMON_QUADS_DRAW_QUAD_H_
|
