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
|
/*
* Copyright (C) 2015 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.
*/
#include "TestUtils.h"
#include "hwui/Paint.h"
#include "DeferredLayerUpdater.h"
#include <renderthread/EglManager.h>
#include <renderthread/OpenGLPipeline.h>
#include <utils/Unicode.h>
namespace android {
namespace uirenderer {
SkColor TestUtils::interpolateColor(float fraction, SkColor start, SkColor end) {
int startA = (start >> 24) & 0xff;
int startR = (start >> 16) & 0xff;
int startG = (start >> 8) & 0xff;
int startB = start & 0xff;
int endA = (end >> 24) & 0xff;
int endR = (end >> 16) & 0xff;
int endG = (end >> 8) & 0xff;
int endB = end & 0xff;
return (int)((startA + (int)(fraction * (endA - startA))) << 24)
| (int)((startR + (int)(fraction * (endR - startR))) << 16)
| (int)((startG + (int)(fraction * (endG - startG))) << 8)
| (int)((startB + (int)(fraction * (endB - startB))));
}
sp<DeferredLayerUpdater> TestUtils::createTextureLayerUpdater(
renderthread::RenderThread& renderThread, uint32_t width, uint32_t height,
const SkMatrix& transform) {
renderthread::OpenGLPipeline pipeline(renderThread);
sp<DeferredLayerUpdater> layerUpdater = pipeline.createTextureLayer();
layerUpdater->backingLayer()->getTransform().load(transform);
layerUpdater->setSize(width, height);
layerUpdater->setTransform(&transform);
// updateLayer so it's ready to draw
layerUpdater->updateLayer(true, GL_TEXTURE_EXTERNAL_OES, Matrix4::identity().data);
return layerUpdater;
}
void TestUtils::layoutTextUnscaled(const SkPaint& paint, const char* text,
std::vector<glyph_t>* outGlyphs, std::vector<float>* outPositions,
float* outTotalAdvance, Rect* outBounds) {
Rect bounds;
float totalAdvance = 0;
SkSurfaceProps surfaceProps(0, kUnknown_SkPixelGeometry);
SkAutoGlyphCacheNoGamma autoCache(paint, &surfaceProps, &SkMatrix::I());
while (*text != '\0') {
size_t nextIndex = 0;
int32_t unichar = utf32_from_utf8_at(text, 4, 0, &nextIndex);
text += nextIndex;
glyph_t glyph = autoCache.getCache()->unicharToGlyph(unichar);
autoCache.getCache()->unicharToGlyph(unichar);
// push glyph and its relative position
outGlyphs->push_back(glyph);
outPositions->push_back(totalAdvance);
outPositions->push_back(0);
// compute bounds
SkGlyph skGlyph = autoCache.getCache()->getUnicharMetrics(unichar);
Rect glyphBounds(skGlyph.fWidth, skGlyph.fHeight);
glyphBounds.translate(totalAdvance + skGlyph.fLeft, skGlyph.fTop);
bounds.unionWith(glyphBounds);
// advance next character
SkScalar skWidth;
paint.getTextWidths(&glyph, sizeof(glyph), &skWidth, NULL);
totalAdvance += skWidth;
}
*outBounds = bounds;
*outTotalAdvance = totalAdvance;
}
void TestUtils::drawUtf8ToCanvas(Canvas* canvas, const char* text,
const SkPaint& paint, float x, float y) {
auto utf16 = asciiToUtf16(text);
canvas->drawText(utf16.get(), 0, strlen(text), strlen(text), x, y, 0, paint, nullptr);
}
void TestUtils::drawUtf8ToCanvas(Canvas* canvas, const char* text,
const SkPaint& paint, const SkPath& path) {
auto utf16 = asciiToUtf16(text);
canvas->drawTextOnPath(utf16.get(), strlen(text), 0, path, 0, 0, paint, nullptr);
}
void TestUtils::TestTask::run() {
// RenderState only valid once RenderThread is running, so queried here
renderthread::RenderThread& renderThread = renderthread::RenderThread::getInstance();
renderThread.eglManager().initialize();
rtCallback(renderThread);
renderThread.renderState().flush(Caches::FlushMode::Full);
renderThread.eglManager().destroy();
}
std::unique_ptr<uint16_t[]> TestUtils::asciiToUtf16(const char* str) {
const int length = strlen(str);
std::unique_ptr<uint16_t[]> utf16(new uint16_t[length]);
for (int i = 0; i < length; i++) {
utf16.get()[i] = str[i];
}
return utf16;
}
} /* namespace uirenderer */
} /* namespace android */
|
