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
|
// Copyright 2019 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.
#include "third_party/blink/renderer/modules/xr/xr_cube_map.h"
#include "base/cxx17_backports.h"
#include "device/vr/public/mojom/vr_service.mojom-blink.h"
#include "third_party/blink/renderer/modules/webgl/webgl_rendering_context_base.h"
#include "third_party/blink/renderer/modules/webgl/webgl_texture.h"
#include "third_party/blink/renderer/modules/xr/xr_cube_map.h"
#include "third_party/blink/renderer/platform/bindings/exception_code.h"
#include "third_party/blink/renderer/platform/graphics/gpu/drawing_buffer.h"
namespace {
bool IsPowerOfTwo(uint32_t value) {
return value && (value & (value - 1)) == 0;
}
// This is an inversion of FloatToHalfFloat in ui/gfx/half_float.cc
float HalfFloatToFloat(const uint16_t input) {
uint32_t tmp = (input & 0x7fff) << 13 | (input & 0x8000) << 16;
float tmp2 = *reinterpret_cast<float*>(&tmp);
return tmp2 / 1.9259299444e-34f;
}
// Linear to sRGB converstion as given in
// https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_framebuffer_sRGB.txt
uint8_t LinearToSrgb(float cl) {
float cs = base::clamp(
cl < 0.0031308f ? 12.92f * cl : 1.055f * std::pow(cl, 0.41666f) - 0.055f,
0.0f, 1.0f);
return static_cast<uint8_t>(255.0f * cs + 0.5f);
}
void Rgba16fToSrgba8(const uint16_t* input,
uint8_t* output,
WTF::wtf_size_t num) {
DCHECK_EQ(num % 4, 0ul);
for (WTF::wtf_size_t i = 0; i < num; i += 4) {
output[i] = LinearToSrgb(HalfFloatToFloat(input[i]));
output[i + 1] = LinearToSrgb(HalfFloatToFloat(input[i + 1]));
output[i + 2] = LinearToSrgb(HalfFloatToFloat(input[i + 2]));
// We won't support non-opaque alpha to make the conversion a bit faster.
output[i + 3] = 255;
}
}
} // namespace
namespace blink {
XRCubeMap::XRCubeMap(const device::mojom::blink::XRCubeMap& cube_map) {
constexpr auto kNumComponentsPerPixel =
device::mojom::blink::XRCubeMap::kNumComponentsPerPixel;
static_assert(kNumComponentsPerPixel == 4,
"XRCubeMaps are expected to be in the RGBA16F format");
// Cube map sides must all be a power-of-two image
bool valid = IsPowerOfTwo(cube_map.width_and_height);
const size_t expected_size =
cube_map.width_and_height * cube_map.width_and_height;
valid &= cube_map.positive_x.size() == expected_size;
valid &= cube_map.negative_x.size() == expected_size;
valid &= cube_map.positive_y.size() == expected_size;
valid &= cube_map.negative_y.size() == expected_size;
valid &= cube_map.positive_z.size() == expected_size;
valid &= cube_map.negative_z.size() == expected_size;
DCHECK(valid);
width_and_height_ = cube_map.width_and_height;
positive_x_ = cube_map.positive_x;
negative_x_ = cube_map.negative_x;
positive_y_ = cube_map.positive_y;
negative_y_ = cube_map.negative_y;
positive_z_ = cube_map.positive_z;
negative_z_ = cube_map.negative_z;
}
WebGLTexture* XRCubeMap::updateWebGLEnvironmentCube(
WebGLRenderingContextBase* context,
WebGLTexture* texture,
GLenum internal_format,
GLenum format,
GLenum type) const {
// Ensure a texture was supplied from the passed context and with an
// appropriate bound target.
DCHECK(texture);
DCHECK(!texture->HasEverBeenBound() ||
texture->GetTarget() == GL_TEXTURE_CUBE_MAP);
DCHECK(texture->ContextGroup() == context->ContextGroup());
auto* gl = context->ContextGL();
texture->SetTarget(GL_TEXTURE_CUBE_MAP);
gl->BindTexture(GL_TEXTURE_CUBE_MAP, texture->Object());
// Cannot generate mip-maps for half-float textures, so use linear filtering
gl->TexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl->TexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
uint16_t const* const cubemap_images[] = {
positive_x_.data()->components, negative_x_.data()->components,
positive_y_.data()->components, negative_y_.data()->components,
positive_z_.data()->components, negative_z_.data()->components,
};
GLenum const cubemap_targets[] = {
GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
};
// Update image for each side of the cube map in the requested format,
// either "srgb8" or "rgba16f".
if (type == GL_UNSIGNED_BYTE) {
// If we've been asked to provide the textures with UNSIGNED_BYTE
// components it means the light probe was created with the "srgb8" format.
// Since ARCore provides texture as half float components, we need to do a
// conversion first to support this path.
// TODO(https://crbug.com/1148605): Do conversions off the main JS thread.
WTF::wtf_size_t component_count = width_and_height_ * width_and_height_ * 4;
WTF::Vector<uint8_t> sRGB(component_count);
for (int i = 0; i < 6; ++i) {
Rgba16fToSrgba8(cubemap_images[i], sRGB.data(), component_count);
auto target = cubemap_targets[i];
gl->TexImage2D(target, 0, internal_format, width_and_height_,
width_and_height_, 0, format, type, sRGB.data());
}
} else if (type == GL_HALF_FLOAT || type == GL_HALF_FLOAT_OES) {
// If we've been asked to provide the textures with one of the HALF_FLOAT
// types it means the light probe was created with the "rgba16f" format.
// This is ARCore's native format, so no conversion is needed.
for (int i = 0; i < 6; ++i) {
auto* image = cubemap_images[i];
auto target = cubemap_targets[i];
gl->TexImage2D(target, 0, internal_format, width_and_height_,
width_and_height_, 0, format, type, image);
}
} else {
// No other formats are accepted.
NOTREACHED();
}
DrawingBuffer::Client* client = static_cast<DrawingBuffer::Client*>(context);
client->DrawingBufferClientRestoreTextureCubeMapBinding();
// Debug check for success
DCHECK(gl->GetError() == GL_NO_ERROR);
return texture;
}
} // namespace blink
|
