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
|
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_HWUI_VERTEX_H
#define ANDROID_HWUI_VERTEX_H
#include "Vector.h"
#include <type_traits>
#define REQUIRE_COMPATIBLE_LAYOUT(TARGET_TYPE) \
static_assert(std::is_standard_layout<TARGET_TYPE>::value, \
#TARGET_TYPE " must have standard layout")
namespace android {
namespace uirenderer {
/**
* Simple structure to describe a vertex with a position and a texture.
*/
struct Vertex {
/**
* Fudge-factor used to disambiguate geometry pixel positioning.
*
* Used to offset lines and points to avoid ambiguous intersection with pixel centers (see
* Program::set()), and used to make geometry damage rect calculation conservative (see
* Rect::snapGeometryToPixelBoundaries())
*/
static float GeometryFudgeFactor() { return 0.0656f; }
float x, y;
static inline void set(Vertex* vertex, float x, float y) {
vertex->x = x;
vertex->y = y;
}
static inline void set(Vertex* vertex, Vector2 val) {
set(vertex, val.x, val.y);
}
static inline void copyWithOffset(Vertex* vertex, const Vertex& src, float x, float y) {
set(vertex, src.x + x, src.y + y);
}
}; // struct Vertex
REQUIRE_COMPATIBLE_LAYOUT(Vertex);
/**
* Simple structure to describe a vertex with a position and texture UV.
*/
struct TextureVertex {
float x, y;
float u, v;
static inline void set(TextureVertex* vertex, float x, float y, float u, float v) {
*vertex = { x, y, u, v };
}
static inline void setUV(TextureVertex* vertex, float u, float v) {
vertex[0].u = u;
vertex[0].v = v;
}
}; // struct TextureVertex
REQUIRE_COMPATIBLE_LAYOUT(TextureVertex);
/**
* Simple structure to describe a vertex with a position, texture UV and ARGB color.
*/
struct ColorTextureVertex {
float x, y;
float u, v;
float r, g, b, a;
static inline void set(ColorTextureVertex* vertex, float x, float y,
float u, float v, int color) {
float a = ((color >> 24) & 0xff) / 255.0f;
float r = a * ((color >> 16) & 0xff) / 255.0f;
float g = a * ((color >> 8) & 0xff) / 255.0f;
float b = a * ((color) & 0xff) / 255.0f;
*vertex = { x, y, u, v, r, g, b, a };
}
}; // struct ColorTextureVertex
REQUIRE_COMPATIBLE_LAYOUT(ColorTextureVertex);
/**
* Simple structure to describe a vertex with a position and an alpha value.
*/
struct AlphaVertex {
float x, y;
float alpha;
static inline void set(AlphaVertex* vertex, float x, float y, float alpha) {
*vertex = { x, y, alpha };
}
static inline void copyWithOffset(AlphaVertex* vertex, const AlphaVertex& src,
float x, float y) {
AlphaVertex::set(vertex, src.x + x, src.y + y, src.alpha);
}
static inline void setColor(AlphaVertex* vertex, float alpha) {
vertex[0].alpha = alpha;
}
}; // struct AlphaVertex
REQUIRE_COMPATIBLE_LAYOUT(AlphaVertex);
}; // namespace uirenderer
}; // namespace android
#endif // ANDROID_HWUI_VERTEX_H
|
