CoCalc -- imageformats.cpp

GitHub Repository: PojavLauncherTeam/angle
Path: blob/main_old/src/image_util/imageformats.cpp
¹⁶⁹³ views
1
//
2
// Copyright 2016 The ANGLE Project Authors. All rights reserved.
3
// Use of this source code is governed by a BSD-style license that can be
4
// found in the LICENSE file.
5
//
6

7
// imageformats.cpp: Defines image format types with functions for mip generation
8
// and copying.
9

10
#include "image_util/imageformats.h"
11

12
#include "common/mathutil.h"
13

14
namespace angle
15
{
16

17
void L8::readColor(gl::ColorF *dst, const L8 *src)
18
{
19
    const float lum = gl::normalizedToFloat(src->L);
20
    dst->red        = lum;
21
    dst->green      = lum;
22
    dst->blue       = lum;
23
    dst->alpha      = 1.0f;
24
}
25

26
void L8::writeColor(L8 *dst, const gl::ColorF *src)
27
{
28
    dst->L = gl::floatToNormalized<uint8_t>(src->red);
29
}
30

31
void L8::average(L8 *dst, const L8 *src1, const L8 *src2)
32
{
33
    dst->L = gl::average(src1->L, src2->L);
34
}
35

36
void R8::readColor(gl::ColorUI *dst, const R8 *src)
37
{
38
    dst->red   = src->R;
39
    dst->green = 0;
40
    dst->blue  = 0;
41
    dst->alpha = 1;
42
}
43

44
void R8::readColor(gl::ColorF *dst, const R8 *src)
45
{
46
    dst->red   = gl::normalizedToFloat(src->R);
47
    dst->green = 0.0f;
48
    dst->blue  = 0.0f;
49
    dst->alpha = 1.0f;
50
}
51

52
void R8::writeColor(R8 *dst, const gl::ColorUI *src)
53
{
54
    dst->R = static_cast<uint8_t>(src->red);
55
}
56

57
void R8::writeColor(R8 *dst, const gl::ColorF *src)
58
{
59
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
60
}
61

62
void R8::average(R8 *dst, const R8 *src1, const R8 *src2)
63
{
64
    dst->R = gl::average(src1->R, src2->R);
65
}
66

67
void A8::readColor(gl::ColorF *dst, const A8 *src)
68
{
69
    dst->red   = 0.0f;
70
    dst->green = 0.0f;
71
    dst->blue  = 0.0f;
72
    dst->alpha = gl::normalizedToFloat(src->A);
73
}
74

75
void A8::writeColor(A8 *dst, const gl::ColorF *src)
76
{
77
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
78
}
79

80
void A8::average(A8 *dst, const A8 *src1, const A8 *src2)
81
{
82
    dst->A = gl::average(src1->A, src2->A);
83
}
84

85
void L8A8::readColor(gl::ColorF *dst, const L8A8 *src)
86
{
87
    const float lum = gl::normalizedToFloat(src->L);
88
    dst->red        = lum;
89
    dst->green      = lum;
90
    dst->blue       = lum;
91
    dst->alpha      = gl::normalizedToFloat(src->A);
92
}
93

94
void L8A8::writeColor(L8A8 *dst, const gl::ColorF *src)
95
{
96
    dst->L = gl::floatToNormalized<uint8_t>(src->red);
97
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
98
}
99

100
void L8A8::average(L8A8 *dst, const L8A8 *src1, const L8A8 *src2)
101
{
102
    *(uint16_t *)dst = (((*(uint16_t *)src1 ^ *(uint16_t *)src2) & 0xFEFE) >> 1) +
103
                       (*(uint16_t *)src1 & *(uint16_t *)src2);
104
}
105

106
void A8L8::readColor(gl::ColorF *dst, const A8L8 *src)
107
{
108
    const float lum = gl::normalizedToFloat(src->L);
109
    dst->red        = lum;
110
    dst->green      = lum;
111
    dst->blue       = lum;
112
    dst->alpha      = gl::normalizedToFloat(src->A);
113
}
114

115
void A8L8::writeColor(A8L8 *dst, const gl::ColorF *src)
116
{
117
    dst->L = gl::floatToNormalized<uint8_t>(src->red);
118
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
119
}
120

121
void A8L8::average(A8L8 *dst, const A8L8 *src1, const A8L8 *src2)
122
{
123
    *(uint16_t *)dst = (((*(uint16_t *)src1 ^ *(uint16_t *)src2) & 0xFEFE) >> 1) +
124
                       (*(uint16_t *)src1 & *(uint16_t *)src2);
125
}
126

127
void R8G8::readColor(gl::ColorUI *dst, const R8G8 *src)
128
{
129
    dst->red   = src->R;
130
    dst->green = src->G;
131
    dst->blue  = 0;
132
    dst->alpha = 1;
133
}
134

135
void R8G8::readColor(gl::ColorF *dst, const R8G8 *src)
136
{
137
    dst->red   = gl::normalizedToFloat(src->R);
138
    dst->green = gl::normalizedToFloat(src->G);
139
    dst->blue  = 0.0f;
140
    dst->alpha = 1.0f;
141
}
142

143
void R8G8::writeColor(R8G8 *dst, const gl::ColorUI *src)
144
{
145
    dst->R = static_cast<uint8_t>(src->red);
146
    dst->G = static_cast<uint8_t>(src->green);
147
}
148

149
void R8G8::writeColor(R8G8 *dst, const gl::ColorF *src)
150
{
151
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
152
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
153
}
154

155
void R8G8::average(R8G8 *dst, const R8G8 *src1, const R8G8 *src2)
156
{
157
    *(uint16_t *)dst = (((*(uint16_t *)src1 ^ *(uint16_t *)src2) & 0xFEFE) >> 1) +
158
                       (*(uint16_t *)src1 & *(uint16_t *)src2);
159
}
160

161
void R8G8B8::readColor(gl::ColorUI *dst, const R8G8B8 *src)
162
{
163
    dst->red   = src->R;
164
    dst->green = src->G;
165
    dst->blue  = src->G;
166
    dst->alpha = 1;
167
}
168

169
void R8G8B8::readColor(gl::ColorF *dst, const R8G8B8 *src)
170
{
171
    dst->red   = gl::normalizedToFloat(src->R);
172
    dst->green = gl::normalizedToFloat(src->G);
173
    dst->blue  = gl::normalizedToFloat(src->B);
174
    dst->alpha = 1.0f;
175
}
176

177
void R8G8B8::writeColor(R8G8B8 *dst, const gl::ColorUI *src)
178
{
179
    dst->R = static_cast<uint8_t>(src->red);
180
    dst->G = static_cast<uint8_t>(src->green);
181
    dst->B = static_cast<uint8_t>(src->blue);
182
}
183

184
void R8G8B8::writeColor(R8G8B8 *dst, const gl::ColorF *src)
185
{
186
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
187
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
188
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
189
}
190

191
void R8G8B8::average(R8G8B8 *dst, const R8G8B8 *src1, const R8G8B8 *src2)
192
{
193
    dst->R = gl::average(src1->R, src2->R);
194
    dst->G = gl::average(src1->G, src2->G);
195
    dst->B = gl::average(src1->B, src2->B);
196
}
197

198
void B8G8R8::readColor(gl::ColorUI *dst, const B8G8R8 *src)
199
{
200
    dst->red   = src->R;
201
    dst->green = src->G;
202
    dst->blue  = src->G;
203
    dst->alpha = 1;
204
}
205

206
void B8G8R8::readColor(gl::ColorF *dst, const B8G8R8 *src)
207
{
208
    dst->red   = gl::normalizedToFloat(src->R);
209
    dst->green = gl::normalizedToFloat(src->G);
210
    dst->blue  = gl::normalizedToFloat(src->B);
211
    dst->alpha = 1.0f;
212
}
213

214
void B8G8R8::writeColor(B8G8R8 *dst, const gl::ColorUI *src)
215
{
216
    dst->R = static_cast<uint8_t>(src->red);
217
    dst->G = static_cast<uint8_t>(src->green);
218
    dst->B = static_cast<uint8_t>(src->blue);
219
}
220

221
void B8G8R8::writeColor(B8G8R8 *dst, const gl::ColorF *src)
222
{
223
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
224
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
225
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
226
}
227

228
void B8G8R8::average(B8G8R8 *dst, const B8G8R8 *src1, const B8G8R8 *src2)
229
{
230
    dst->R = gl::average(src1->R, src2->R);
231
    dst->G = gl::average(src1->G, src2->G);
232
    dst->B = gl::average(src1->B, src2->B);
233
}
234

235
void R5G6B5::readColor(gl::ColorF *dst, const R5G6B5 *src)
236
{
237
    dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->RGB));
238
    dst->green = gl::normalizedToFloat<6>(gl::getShiftedData<6, 5>(src->RGB));
239
    dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->RGB));
240
    dst->alpha = 1.0f;
241
}
242

243
void R5G6B5::writeColor(R5G6B5 *dst, const gl::ColorF *src)
244
{
245
    dst->RGB = gl::shiftData<5, 11>(gl::floatToNormalized<5, uint16_t>(src->red)) |
246
               gl::shiftData<6, 5>(gl::floatToNormalized<6, uint16_t>(src->green)) |
247
               gl::shiftData<5, 0>(gl::floatToNormalized<5, uint16_t>(src->blue));
248
}
249

250
void R5G6B5::average(R5G6B5 *dst, const R5G6B5 *src1, const R5G6B5 *src2)
251
{
252
    dst->RGB = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->RGB),
253
                                                gl::getShiftedData<5, 11>(src2->RGB))) |
254
               gl::shiftData<6, 5>(gl::average(gl::getShiftedData<6, 5>(src1->RGB),
255
                                               gl::getShiftedData<6, 5>(src2->RGB))) |
256
               gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->RGB),
257
                                               gl::getShiftedData<5, 0>(src2->RGB)));
258
}
259

260
void B5G6R5::readColor(gl::ColorF *dst, const B5G6R5 *src)
261
{
262
    dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->BGR));
263
    dst->green = gl::normalizedToFloat<6>(gl::getShiftedData<6, 5>(src->BGR));
264
    dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->BGR));
265
    dst->alpha = 1.0f;
266
}
267

268
void B5G6R5::writeColor(B5G6R5 *dst, const gl::ColorF *src)
269
{
270
    dst->BGR = gl::shiftData<5, 0>(gl::floatToNormalized<5, unsigned short>(src->blue)) |
271
               gl::shiftData<6, 5>(gl::floatToNormalized<6, unsigned short>(src->green)) |
272
               gl::shiftData<5, 11>(gl::floatToNormalized<5, unsigned short>(src->red));
273
}
274

275
void B5G6R5::average(B5G6R5 *dst, const B5G6R5 *src1, const B5G6R5 *src2)
276
{
277
    dst->BGR = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->BGR),
278
                                                gl::getShiftedData<5, 11>(src2->BGR))) |
279
               gl::shiftData<6, 5>(gl::average(gl::getShiftedData<6, 5>(src1->BGR),
280
                                               gl::getShiftedData<6, 5>(src2->BGR))) |
281
               gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->BGR),
282
                                               gl::getShiftedData<5, 0>(src2->BGR)));
283
}
284

285
void A8R8G8B8::readColor(gl::ColorUI *dst, const A8R8G8B8 *src)
286
{
287
    dst->red   = src->R;
288
    dst->green = src->G;
289
    dst->blue  = src->B;
290
    dst->alpha = src->A;
291
}
292

293
void A8R8G8B8::readColor(gl::ColorF *dst, const A8R8G8B8 *src)
294
{
295
    dst->red   = gl::normalizedToFloat(src->R);
296
    dst->green = gl::normalizedToFloat(src->G);
297
    dst->blue  = gl::normalizedToFloat(src->B);
298
    dst->alpha = gl::normalizedToFloat(src->A);
299
}
300

301
void A8R8G8B8::writeColor(A8R8G8B8 *dst, const gl::ColorUI *src)
302
{
303
    dst->R = static_cast<uint8_t>(src->red);
304
    dst->G = static_cast<uint8_t>(src->green);
305
    dst->B = static_cast<uint8_t>(src->blue);
306
    dst->A = static_cast<uint8_t>(src->alpha);
307
}
308

309
void A8R8G8B8::writeColor(A8R8G8B8 *dst, const gl::ColorF *src)
310
{
311
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
312
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
313
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
314
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
315
}
316

317
void A8R8G8B8::average(A8R8G8B8 *dst, const A8R8G8B8 *src1, const A8R8G8B8 *src2)
318
{
319
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
320
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
321
}
322

323
void R8G8B8A8::readColor(gl::ColorUI *dst, const R8G8B8A8 *src)
324
{
325
    dst->red   = src->R;
326
    dst->green = src->G;
327
    dst->blue  = src->B;
328
    dst->alpha = src->A;
329
}
330

331
void R8G8B8A8::readColor(gl::ColorF *dst, const R8G8B8A8 *src)
332
{
333
    dst->red   = gl::normalizedToFloat(src->R);
334
    dst->green = gl::normalizedToFloat(src->G);
335
    dst->blue  = gl::normalizedToFloat(src->B);
336
    dst->alpha = gl::normalizedToFloat(src->A);
337
}
338

339
void R8G8B8A8::writeColor(R8G8B8A8 *dst, const gl::ColorUI *src)
340
{
341
    dst->R = static_cast<uint8_t>(src->red);
342
    dst->G = static_cast<uint8_t>(src->green);
343
    dst->B = static_cast<uint8_t>(src->blue);
344
    dst->A = static_cast<uint8_t>(src->alpha);
345
}
346

347
void R8G8B8A8::writeColor(R8G8B8A8 *dst, const gl::ColorF *src)
348
{
349
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
350
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
351
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
352
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
353
}
354

355
void R8G8B8A8::average(R8G8B8A8 *dst, const R8G8B8A8 *src1, const R8G8B8A8 *src2)
356
{
357
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
358
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
359
}
360

361
void R8G8B8A8SRGB::readColor(gl::ColorF *dst, const R8G8B8A8SRGB *src)
362
{
363
    dst->red   = gl::normalizedToFloat(src->R);
364
    dst->green = gl::normalizedToFloat(src->G);
365
    dst->blue  = gl::normalizedToFloat(src->B);
366
    dst->alpha = gl::normalizedToFloat(src->A);
367
}
368

369
void R8G8B8A8SRGB::writeColor(R8G8B8A8SRGB *dst, const gl::ColorF *src)
370
{
371
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
372
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
373
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
374
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
375
}
376

377
void R8G8B8A8SRGB::average(R8G8B8A8SRGB *dst, const R8G8B8A8SRGB *src1, const R8G8B8A8SRGB *src2)
378
{
379
    dst->R =
380
        gl::linearToSRGB(static_cast<uint8_t>((static_cast<uint16_t>(gl::sRGBToLinear(src1->R)) +
381
                                               static_cast<uint16_t>(gl::sRGBToLinear(src2->R))) >>
382
                                              1));
383
    dst->G =
384
        gl::linearToSRGB(static_cast<uint8_t>((static_cast<uint16_t>(gl::sRGBToLinear(src1->G)) +
385
                                               static_cast<uint16_t>(gl::sRGBToLinear(src2->G))) >>
386
                                              1));
387
    dst->B =
388
        gl::linearToSRGB(static_cast<uint8_t>((static_cast<uint16_t>(gl::sRGBToLinear(src1->B)) +
389
                                               static_cast<uint16_t>(gl::sRGBToLinear(src2->B))) >>
390
                                              1));
391
    dst->A = static_cast<uint8_t>(
392
        (static_cast<uint16_t>(src1->A) + static_cast<uint16_t>(src2->A)) >> 1);
393
}
394

395
void B8G8R8A8::readColor(gl::ColorUI *dst, const B8G8R8A8 *src)
396
{
397
    dst->red   = src->R;
398
    dst->green = src->G;
399
    dst->blue  = src->B;
400
    dst->alpha = src->A;
401
}
402

403
void B8G8R8A8::readColor(gl::ColorF *dst, const B8G8R8A8 *src)
404
{
405
    dst->red   = gl::normalizedToFloat(src->R);
406
    dst->green = gl::normalizedToFloat(src->G);
407
    dst->blue  = gl::normalizedToFloat(src->B);
408
    dst->alpha = gl::normalizedToFloat(src->A);
409
}
410

411
void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorUI *src)
412
{
413
    dst->R = static_cast<uint8_t>(src->red);
414
    dst->G = static_cast<uint8_t>(src->green);
415
    dst->B = static_cast<uint8_t>(src->blue);
416
    dst->A = static_cast<uint8_t>(src->alpha);
417
}
418

419
void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorF *src)
420
{
421
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
422
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
423
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
424
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
425
}
426

427
void B8G8R8A8::average(B8G8R8A8 *dst, const B8G8R8A8 *src1, const B8G8R8A8 *src2)
428
{
429
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
430
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
431
}
432

433
void B8G8R8X8::readColor(gl::ColorUI *dst, const B8G8R8X8 *src)
434
{
435
    dst->red   = src->R;
436
    dst->green = src->G;
437
    dst->blue  = src->B;
438
    dst->alpha = 1;
439
}
440

441
void B8G8R8X8::readColor(gl::ColorF *dst, const B8G8R8X8 *src)
442
{
443
    dst->red   = gl::normalizedToFloat(src->R);
444
    dst->green = gl::normalizedToFloat(src->G);
445
    dst->blue  = gl::normalizedToFloat(src->B);
446
    dst->alpha = 1.0f;
447
}
448

449
void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorUI *src)
450
{
451
    dst->R = static_cast<uint8_t>(src->red);
452
    dst->G = static_cast<uint8_t>(src->green);
453
    dst->B = static_cast<uint8_t>(src->blue);
454
    dst->X = 255;
455
}
456

457
void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorF *src)
458
{
459
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
460
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
461
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
462
    dst->X = 255;
463
}
464

465
void B8G8R8X8::average(B8G8R8X8 *dst, const B8G8R8X8 *src1, const B8G8R8X8 *src2)
466
{
467
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
468
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
469
    dst->X = 255;
470
}
471

472
void A1R5G5B5::readColor(gl::ColorF *dst, const A1R5G5B5 *src)
473
{
474
    dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 15>(src->ARGB));
475
    dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 10>(src->ARGB));
476
    dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5, 5>(src->ARGB));
477
    dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->ARGB));
478
}
479

480
void A1R5G5B5::writeColor(A1R5G5B5 *dst, const gl::ColorF *src)
481
{
482
    dst->ARGB = gl::shiftData<1, 15>(gl::floatToNormalized<1, uint16_t>(src->alpha)) |
483
                gl::shiftData<5, 10>(gl::floatToNormalized<5, uint16_t>(src->red)) |
484
                gl::shiftData<5, 5>(gl::floatToNormalized<5, uint16_t>(src->green)) |
485
                gl::shiftData<5, 0>(gl::floatToNormalized<5, uint16_t>(src->blue));
486
}
487

488
void A1R5G5B5::average(A1R5G5B5 *dst, const A1R5G5B5 *src1, const A1R5G5B5 *src2)
489
{
490
    dst->ARGB = gl::shiftData<1, 15>(gl::average(gl::getShiftedData<1, 15>(src1->ARGB),
491
                                                 gl::getShiftedData<1, 15>(src2->ARGB))) |
492
                gl::shiftData<5, 10>(gl::average(gl::getShiftedData<5, 10>(src1->ARGB),
493
                                                 gl::getShiftedData<5, 10>(src2->ARGB))) |
494
                gl::shiftData<5, 5>(gl::average(gl::getShiftedData<5, 5>(src1->ARGB),
495
                                                gl::getShiftedData<5, 5>(src2->ARGB))) |
496
                gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->ARGB),
497
                                                gl::getShiftedData<5, 0>(src2->ARGB)));
498
}
499

500
void R5G5B5A1::readColor(gl::ColorF *dst, const R5G5B5A1 *src)
501
{
502
    dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->RGBA));
503
    dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5, 6>(src->RGBA));
504
    dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5, 1>(src->RGBA));
505
    dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 0>(src->RGBA));
506
}
507

508
void R5G5B5A1::writeColor(R5G5B5A1 *dst, const gl::ColorF *src)
509
{
510
    dst->RGBA = gl::shiftData<5, 11>(gl::floatToNormalized<5, uint16_t>(src->red)) |
511
                gl::shiftData<5, 6>(gl::floatToNormalized<5, uint16_t>(src->green)) |
512
                gl::shiftData<5, 1>(gl::floatToNormalized<5, uint16_t>(src->blue)) |
513
                gl::shiftData<1, 0>(gl::floatToNormalized<1, uint16_t>(src->alpha));
514
}
515

516
void R5G5B5A1::average(R5G5B5A1 *dst, const R5G5B5A1 *src1, const R5G5B5A1 *src2)
517
{
518
    dst->RGBA = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->RGBA),
519
                                                 gl::getShiftedData<5, 11>(src2->RGBA))) |
520
                gl::shiftData<5, 6>(gl::average(gl::getShiftedData<5, 6>(src1->RGBA),
521
                                                gl::getShiftedData<5, 6>(src2->RGBA))) |
522
                gl::shiftData<5, 1>(gl::average(gl::getShiftedData<5, 1>(src1->RGBA),
523
                                                gl::getShiftedData<5, 1>(src2->RGBA))) |
524
                gl::shiftData<1, 0>(gl::average(gl::getShiftedData<1, 0>(src1->RGBA),
525
                                                gl::getShiftedData<1, 0>(src2->RGBA)));
526
}
527

528
void R4G4B4A4::readColor(gl::ColorF *dst, const R4G4B4A4 *src)
529
{
530
    dst->red   = gl::normalizedToFloat<4>(gl::getShiftedData<4, 12>(src->RGBA));
531
    dst->green = gl::normalizedToFloat<4>(gl::getShiftedData<4, 8>(src->RGBA));
532
    dst->blue  = gl::normalizedToFloat<4>(gl::getShiftedData<4, 4>(src->RGBA));
533
    dst->alpha = gl::normalizedToFloat<4>(gl::getShiftedData<4, 0>(src->RGBA));
534
}
535

536
void R4G4B4A4::writeColor(R4G4B4A4 *dst, const gl::ColorF *src)
537
{
538
    dst->RGBA = gl::shiftData<4, 12>(gl::floatToNormalized<4, uint16_t>(src->red)) |
539
                gl::shiftData<4, 8>(gl::floatToNormalized<4, uint16_t>(src->green)) |
540
                gl::shiftData<4, 4>(gl::floatToNormalized<4, uint16_t>(src->blue)) |
541
                gl::shiftData<4, 0>(gl::floatToNormalized<4, uint16_t>(src->alpha));
542
}
543

544
void R4G4B4A4::average(R4G4B4A4 *dst, const R4G4B4A4 *src1, const R4G4B4A4 *src2)
545
{
546
    dst->RGBA = gl::shiftData<4, 12>(gl::average(gl::getShiftedData<4, 12>(src1->RGBA),
547
                                                 gl::getShiftedData<4, 12>(src2->RGBA))) |
548
                gl::shiftData<4, 8>(gl::average(gl::getShiftedData<4, 8>(src1->RGBA),
549
                                                gl::getShiftedData<4, 8>(src2->RGBA))) |
550
                gl::shiftData<4, 4>(gl::average(gl::getShiftedData<4, 4>(src1->RGBA),
551
                                                gl::getShiftedData<4, 4>(src2->RGBA))) |
552
                gl::shiftData<4, 0>(gl::average(gl::getShiftedData<4, 0>(src1->RGBA),
553
                                                gl::getShiftedData<4, 0>(src2->RGBA)));
554
}
555

556
void A4R4G4B4::readColor(gl::ColorF *dst, const A4R4G4B4 *src)
557
{
558
    dst->alpha = gl::normalizedToFloat<4>(gl::getShiftedData<4, 12>(src->ARGB));
559
    dst->red   = gl::normalizedToFloat<4>(gl::getShiftedData<4, 8>(src->ARGB));
560
    dst->green = gl::normalizedToFloat<4>(gl::getShiftedData<4, 4>(src->ARGB));
561
    dst->blue  = gl::normalizedToFloat<4>(gl::getShiftedData<4, 0>(src->ARGB));
562
}
563

564
void A4R4G4B4::writeColor(A4R4G4B4 *dst, const gl::ColorF *src)
565
{
566
    dst->ARGB = gl::shiftData<4, 12>(gl::floatToNormalized<4, uint16_t>(src->alpha)) |
567
                gl::shiftData<4, 8>(gl::floatToNormalized<4, uint16_t>(src->red)) |
568
                gl::shiftData<4, 4>(gl::floatToNormalized<4, uint16_t>(src->green)) |
569
                gl::shiftData<4, 0>(gl::floatToNormalized<4, uint16_t>(src->blue));
570
}
571

572
void A4R4G4B4::average(A4R4G4B4 *dst, const A4R4G4B4 *src1, const A4R4G4B4 *src2)
573
{
574
    dst->ARGB = gl::shiftData<4, 12>(gl::average(gl::getShiftedData<4, 12>(src1->ARGB),
575
                                                 gl::getShiftedData<4, 12>(src2->ARGB))) |
576
                gl::shiftData<4, 8>(gl::average(gl::getShiftedData<4, 8>(src1->ARGB),
577
                                                gl::getShiftedData<4, 8>(src2->ARGB))) |
578
                gl::shiftData<4, 4>(gl::average(gl::getShiftedData<4, 4>(src1->ARGB),
579
                                                gl::getShiftedData<4, 4>(src2->ARGB))) |
580
                gl::shiftData<4, 0>(gl::average(gl::getShiftedData<4, 0>(src1->ARGB),
581
                                                gl::getShiftedData<4, 0>(src2->ARGB)));
582
}
583

584
void R16::readColor(gl::ColorUI *dst, const R16 *src)
585
{
586
    dst->red   = src->R;
587
    dst->green = 0;
588
    dst->blue  = 0;
589
    dst->alpha = 1;
590
}
591

592
void R16::readColor(gl::ColorF *dst, const R16 *src)
593
{
594
    dst->red   = gl::normalizedToFloat(src->R);
595
    dst->green = 0.0f;
596
    dst->blue  = 0.0f;
597
    dst->alpha = 1.0f;
598
}
599

600
void R16::writeColor(R16 *dst, const gl::ColorUI *src)
601
{
602
    dst->R = static_cast<uint16_t>(src->red);
603
}
604

605
void R16::writeColor(R16 *dst, const gl::ColorF *src)
606
{
607
    dst->R = gl::floatToNormalized<uint16_t>(src->red);
608
}
609

610
void R16::average(R16 *dst, const R16 *src1, const R16 *src2)
611
{
612
    dst->R = gl::average(src1->R, src2->R);
613
}
614

615
void R16G16::readColor(gl::ColorUI *dst, const R16G16 *src)
616
{
617
    dst->red   = src->R;
618
    dst->green = src->G;
619
    dst->blue  = 0;
620
    dst->alpha = 1;
621
}
622

623
void R16G16::readColor(gl::ColorF *dst, const R16G16 *src)
624
{
625
    dst->red   = gl::normalizedToFloat(src->R);
626
    dst->green = gl::normalizedToFloat(src->G);
627
    dst->blue  = 0.0f;
628
    dst->alpha = 1.0f;
629
}
630

631
void R16G16::writeColor(R16G16 *dst, const gl::ColorUI *src)
632
{
633
    dst->R = static_cast<uint16_t>(src->red);
634
    dst->G = static_cast<uint16_t>(src->green);
635
}
636

637
void R16G16::writeColor(R16G16 *dst, const gl::ColorF *src)
638
{
639
    dst->R = gl::floatToNormalized<uint16_t>(src->red);
640
    dst->G = gl::floatToNormalized<uint16_t>(src->green);
641
}
642

643
void R16G16::average(R16G16 *dst, const R16G16 *src1, const R16G16 *src2)
644
{
645
    dst->R = gl::average(src1->R, src2->R);
646
    dst->G = gl::average(src1->G, src2->G);
647
}
648

649
void R16G16B16::readColor(gl::ColorUI *dst, const R16G16B16 *src)
650
{
651
    dst->red   = src->R;
652
    dst->green = src->G;
653
    dst->blue  = src->B;
654
    dst->alpha = 1;
655
}
656

657
void R16G16B16::readColor(gl::ColorF *dst, const R16G16B16 *src)
658
{
659
    dst->red   = gl::normalizedToFloat(src->R);
660
    dst->green = gl::normalizedToFloat(src->G);
661
    dst->blue  = gl::normalizedToFloat(src->B);
662
    dst->alpha = 1.0f;
663
}
664

665
void R16G16B16::writeColor(R16G16B16 *dst, const gl::ColorUI *src)
666
{
667
    dst->R = static_cast<uint16_t>(src->red);
668
    dst->G = static_cast<uint16_t>(src->green);
669
    dst->B = static_cast<uint16_t>(src->blue);
670
}
671

672
void R16G16B16::writeColor(R16G16B16 *dst, const gl::ColorF *src)
673
{
674
    dst->R = gl::floatToNormalized<uint16_t>(src->red);
675
    dst->G = gl::floatToNormalized<uint16_t>(src->green);
676
    dst->B = gl::floatToNormalized<uint16_t>(src->blue);
677
}
678

679
void R16G16B16::average(R16G16B16 *dst, const R16G16B16 *src1, const R16G16B16 *src2)
680
{
681
    dst->R = gl::average(src1->R, src2->R);
682
    dst->G = gl::average(src1->G, src2->G);
683
    dst->B = gl::average(src1->B, src2->B);
684
}
685

686
void R16G16B16A16::readColor(gl::ColorUI *dst, const R16G16B16A16 *src)
687
{
688
    dst->red   = src->R;
689
    dst->green = src->G;
690
    dst->blue  = src->B;
691
    dst->alpha = src->A;
692
}
693

694
void R16G16B16A16::readColor(gl::ColorF *dst, const R16G16B16A16 *src)
695
{
696
    dst->red   = gl::normalizedToFloat(src->R);
697
    dst->green = gl::normalizedToFloat(src->G);
698
    dst->blue  = gl::normalizedToFloat(src->B);
699
    dst->alpha = gl::normalizedToFloat(src->A);
700
}
701

702
void R16G16B16A16::writeColor(R16G16B16A16 *dst, const gl::ColorUI *src)
703
{
704
    dst->R = static_cast<uint16_t>(src->red);
705
    dst->G = static_cast<uint16_t>(src->green);
706
    dst->B = static_cast<uint16_t>(src->blue);
707
    dst->A = static_cast<uint16_t>(src->alpha);
708
}
709

710
void R16G16B16A16::writeColor(R16G16B16A16 *dst, const gl::ColorF *src)
711
{
712
    dst->R = gl::floatToNormalized<uint16_t>(src->red);
713
    dst->G = gl::floatToNormalized<uint16_t>(src->green);
714
    dst->B = gl::floatToNormalized<uint16_t>(src->blue);
715
    dst->A = gl::floatToNormalized<uint16_t>(src->alpha);
716
}
717

718
void R16G16B16A16::average(R16G16B16A16 *dst, const R16G16B16A16 *src1, const R16G16B16A16 *src2)
719
{
720
    dst->R = gl::average(src1->R, src2->R);
721
    dst->G = gl::average(src1->G, src2->G);
722
    dst->B = gl::average(src1->B, src2->B);
723
    dst->A = gl::average(src1->A, src2->A);
724
}
725

726
void R32::readColor(gl::ColorUI *dst, const R32 *src)
727
{
728
    dst->red   = src->R;
729
    dst->green = 0;
730
    dst->blue  = 0;
731
    dst->alpha = 1;
732
}
733

734
void R32::readColor(gl::ColorF *dst, const R32 *src)
735
{
736
    dst->red   = gl::normalizedToFloat(src->R);
737
    dst->green = 0.0f;
738
    dst->blue  = 0.0f;
739
    dst->alpha = 1.0f;
740
}
741

742
void R32::writeColor(R32 *dst, const gl::ColorUI *src)
743
{
744
    dst->R = static_cast<uint32_t>(src->red);
745
}
746

747
void R32::writeColor(R32 *dst, const gl::ColorF *src)
748
{
749
    dst->R = gl::floatToNormalized<uint32_t>(src->red);
750
}
751

752
void R32::average(R32 *dst, const R32 *src1, const R32 *src2)
753
{
754
    dst->R = gl::average(src1->R, src2->R);
755
}
756

757
void R32G32::readColor(gl::ColorUI *dst, const R32G32 *src)
758
{
759
    dst->red   = src->R;
760
    dst->green = src->G;
761
    dst->blue  = 0;
762
    dst->alpha = 1;
763
}
764

765
void R32G32::readColor(gl::ColorF *dst, const R32G32 *src)
766
{
767
    dst->red   = gl::normalizedToFloat(src->R);
768
    dst->green = gl::normalizedToFloat(src->G);
769
    dst->blue  = 0.0f;
770
    dst->alpha = 1.0f;
771
}
772

773
void R32G32::writeColor(R32G32 *dst, const gl::ColorUI *src)
774
{
775
    dst->R = static_cast<uint32_t>(src->red);
776
    dst->G = static_cast<uint32_t>(src->green);
777
}
778

779
void R32G32::writeColor(R32G32 *dst, const gl::ColorF *src)
780
{
781
    dst->R = gl::floatToNormalized<uint32_t>(src->red);
782
    dst->G = gl::floatToNormalized<uint32_t>(src->green);
783
}
784

785
void R32G32::average(R32G32 *dst, const R32G32 *src1, const R32G32 *src2)
786
{
787
    dst->R = gl::average(src1->R, src2->R);
788
    dst->G = gl::average(src1->G, src2->G);
789
}
790

791
void R32G32B32::readColor(gl::ColorUI *dst, const R32G32B32 *src)
792
{
793
    dst->red   = src->R;
794
    dst->green = src->G;
795
    dst->blue  = src->B;
796
    dst->alpha = 1;
797
}
798

799
void R32G32B32::readColor(gl::ColorF *dst, const R32G32B32 *src)
800
{
801
    dst->red   = gl::normalizedToFloat(src->R);
802
    dst->green = gl::normalizedToFloat(src->G);
803
    dst->blue  = gl::normalizedToFloat(src->B);
804
    dst->alpha = 1.0f;
805
}
806

807
void R32G32B32::writeColor(R32G32B32 *dst, const gl::ColorUI *src)
808
{
809
    dst->R = static_cast<uint32_t>(src->red);
810
    dst->G = static_cast<uint32_t>(src->green);
811
    dst->B = static_cast<uint32_t>(src->blue);
812
}
813

814
void R32G32B32::writeColor(R32G32B32 *dst, const gl::ColorF *src)
815
{
816
    dst->R = gl::floatToNormalized<uint32_t>(src->red);
817
    dst->G = gl::floatToNormalized<uint32_t>(src->green);
818
    dst->B = gl::floatToNormalized<uint32_t>(src->blue);
819
}
820

821
void R32G32B32::average(R32G32B32 *dst, const R32G32B32 *src1, const R32G32B32 *src2)
822
{
823
    dst->R = gl::average(src1->R, src2->R);
824
    dst->G = gl::average(src1->G, src2->G);
825
    dst->B = gl::average(src1->B, src2->B);
826
}
827

828
void R32G32B32A32::readColor(gl::ColorUI *dst, const R32G32B32A32 *src)
829
{
830
    dst->red   = src->R;
831
    dst->green = src->G;
832
    dst->blue  = src->B;
833
    dst->alpha = src->A;
834
}
835

836
void R32G32B32A32::readColor(gl::ColorF *dst, const R32G32B32A32 *src)
837
{
838
    dst->red   = gl::normalizedToFloat(src->R);
839
    dst->green = gl::normalizedToFloat(src->G);
840
    dst->blue  = gl::normalizedToFloat(src->B);
841
    dst->alpha = gl::normalizedToFloat(src->A);
842
}
843

844
void R32G32B32A32::writeColor(R32G32B32A32 *dst, const gl::ColorUI *src)
845
{
846
    dst->R = static_cast<uint32_t>(src->red);
847
    dst->G = static_cast<uint32_t>(src->green);
848
    dst->B = static_cast<uint32_t>(src->blue);
849
    dst->A = static_cast<uint32_t>(src->alpha);
850
}
851

852
void R32G32B32A32::writeColor(R32G32B32A32 *dst, const gl::ColorF *src)
853
{
854
    dst->R = gl::floatToNormalized<uint32_t>(src->red);
855
    dst->G = gl::floatToNormalized<uint32_t>(src->green);
856
    dst->B = gl::floatToNormalized<uint32_t>(src->blue);
857
    dst->A = gl::floatToNormalized<uint32_t>(src->alpha);
858
}
859

860
void R32G32B32A32::average(R32G32B32A32 *dst, const R32G32B32A32 *src1, const R32G32B32A32 *src2)
861
{
862
    dst->R = gl::average(src1->R, src2->R);
863
    dst->G = gl::average(src1->G, src2->G);
864
    dst->B = gl::average(src1->B, src2->B);
865
    dst->A = gl::average(src1->A, src2->A);
866
}
867

868
void R8S::readColor(gl::ColorI *dst, const R8S *src)
869
{
870
    dst->red   = src->R;
871
    dst->green = 0;
872
    dst->blue  = 0;
873
    dst->alpha = 1;
874
}
875

876
void R8S::readColor(gl::ColorF *dst, const R8S *src)
877
{
878
    dst->red   = gl::normalizedToFloat(src->R);
879
    dst->green = 0.0f;
880
    dst->blue  = 0.0f;
881
    dst->alpha = 1.0f;
882
}
883

884
void R8S::writeColor(R8S *dst, const gl::ColorI *src)
885
{
886
    dst->R = static_cast<int8_t>(src->red);
887
}
888

889
void R8S::writeColor(R8S *dst, const gl::ColorF *src)
890
{
891
    dst->R = gl::floatToNormalized<int8_t>(src->red);
892
}
893

894
void R8S::average(R8S *dst, const R8S *src1, const R8S *src2)
895
{
896
    dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
897
}
898

899
void R8G8S::readColor(gl::ColorI *dst, const R8G8S *src)
900
{
901
    dst->red   = src->R;
902
    dst->green = src->G;
903
    dst->blue  = 0;
904
    dst->alpha = 1;
905
}
906

907
void R8G8S::readColor(gl::ColorF *dst, const R8G8S *src)
908
{
909
    dst->red   = gl::normalizedToFloat(src->R);
910
    dst->green = gl::normalizedToFloat(src->G);
911
    dst->blue  = 0.0f;
912
    dst->alpha = 1.0f;
913
}
914

915
void R8G8S::writeColor(R8G8S *dst, const gl::ColorI *src)
916
{
917
    dst->R = static_cast<int8_t>(src->red);
918
    dst->G = static_cast<int8_t>(src->green);
919
}
920

921
void R8G8S::writeColor(R8G8S *dst, const gl::ColorF *src)
922
{
923
    dst->R = gl::floatToNormalized<int8_t>(src->red);
924
    dst->G = gl::floatToNormalized<int8_t>(src->green);
925
}
926

927
void R8G8S::average(R8G8S *dst, const R8G8S *src1, const R8G8S *src2)
928
{
929
    dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
930
    dst->G = static_cast<int8_t>(gl::average(src1->G, src2->G));
931
}
932

933
void R8G8B8S::readColor(gl::ColorI *dst, const R8G8B8S *src)
934
{
935
    dst->red   = src->R;
936
    dst->green = src->G;
937
    dst->blue  = src->B;
938
    dst->alpha = 1;
939
}
940

941
void R8G8B8S::readColor(gl::ColorF *dst, const R8G8B8S *src)
942
{
943
    dst->red   = gl::normalizedToFloat(src->R);
944
    dst->green = gl::normalizedToFloat(src->G);
945
    dst->blue  = gl::normalizedToFloat(src->B);
946
    dst->alpha = 1.0f;
947
}
948

949
void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorI *src)
950
{
951
    dst->R = static_cast<int8_t>(src->red);
952
    dst->G = static_cast<int8_t>(src->green);
953
    dst->B = static_cast<int8_t>(src->blue);
954
}
955

956
void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorF *src)
957
{
958
    dst->R = gl::floatToNormalized<int8_t>(src->red);
959
    dst->G = gl::floatToNormalized<int8_t>(src->green);
960
    dst->B = gl::floatToNormalized<int8_t>(src->blue);
961
}
962

963
void R8G8B8S::average(R8G8B8S *dst, const R8G8B8S *src1, const R8G8B8S *src2)
964
{
965
    dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
966
    dst->G = static_cast<int8_t>(gl::average(src1->G, src2->G));
967
    dst->B = static_cast<int8_t>(gl::average(src1->B, src2->B));
968
}
969

970
void R8G8B8A8S::readColor(gl::ColorI *dst, const R8G8B8A8S *src)
971
{
972
    dst->red   = src->R;
973
    dst->green = src->G;
974
    dst->blue  = src->B;
975
    dst->alpha = src->A;
976
}
977

978
void R8G8B8A8S::readColor(gl::ColorF *dst, const R8G8B8A8S *src)
979
{
980
    dst->red   = gl::normalizedToFloat(src->R);
981
    dst->green = gl::normalizedToFloat(src->G);
982
    dst->blue  = gl::normalizedToFloat(src->B);
983
    dst->alpha = gl::normalizedToFloat(src->A);
984
}
985

986
void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorI *src)
987
{
988
    dst->R = static_cast<int8_t>(src->red);
989
    dst->G = static_cast<int8_t>(src->green);
990
    dst->B = static_cast<int8_t>(src->blue);
991
    dst->A = static_cast<int8_t>(src->alpha);
992
}
993

994
void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorF *src)
995
{
996
    dst->R = gl::floatToNormalized<int8_t>(src->red);
997
    dst->G = gl::floatToNormalized<int8_t>(src->green);
998
    dst->B = gl::floatToNormalized<int8_t>(src->blue);
999
    dst->A = gl::floatToNormalized<int8_t>(src->alpha);
1000
}
1001

1002
void R8G8B8A8S::average(R8G8B8A8S *dst, const R8G8B8A8S *src1, const R8G8B8A8S *src2)
1003
{
1004
    dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
1005
    dst->G = static_cast<int8_t>(gl::average(src1->G, src2->G));
1006
    dst->B = static_cast<int8_t>(gl::average(src1->B, src2->B));
1007
    dst->A = static_cast<int8_t>(gl::average(src1->A, src2->A));
1008
}
1009

1010
void R16S::readColor(gl::ColorI *dst, const R16S *src)
1011
{
1012
    dst->red   = src->R;
1013
    dst->green = 0;
1014
    dst->blue  = 0;
1015
    dst->alpha = 1;
1016
}
1017

1018
void R16S::readColor(gl::ColorF *dst, const R16S *src)
1019
{
1020
    dst->red   = gl::normalizedToFloat(src->R);
1021
    dst->green = 0.0f;
1022
    dst->blue  = 0.0f;
1023
    dst->alpha = 1.0f;
1024
}
1025

1026
void R16S::writeColor(R16S *dst, const gl::ColorI *src)
1027
{
1028
    dst->R = static_cast<int16_t>(src->red);
1029
}
1030

1031
void R16S::writeColor(R16S *dst, const gl::ColorF *src)
1032
{
1033
    dst->R = gl::floatToNormalized<int16_t>(src->red);
1034
}
1035

1036
void R16S::average(R16S *dst, const R16S *src1, const R16S *src2)
1037
{
1038
    dst->R = gl::average(src1->R, src2->R);
1039
}
1040

1041
void R16G16S::readColor(gl::ColorI *dst, const R16G16S *src)
1042
{
1043
    dst->red   = src->R;
1044
    dst->green = src->G;
1045
    dst->blue  = 0;
1046
    dst->alpha = 1;
1047
}
1048

1049
void R16G16S::readColor(gl::ColorF *dst, const R16G16S *src)
1050
{
1051
    dst->red   = gl::normalizedToFloat(src->R);
1052
    dst->green = gl::normalizedToFloat(src->G);
1053
    dst->blue  = 0.0f;
1054
    dst->alpha = 1.0f;
1055
}
1056

1057
void R16G16S::writeColor(R16G16S *dst, const gl::ColorI *src)
1058
{
1059
    dst->R = static_cast<int16_t>(src->red);
1060
    dst->G = static_cast<int16_t>(src->green);
1061
}
1062

1063
void R16G16S::writeColor(R16G16S *dst, const gl::ColorF *src)
1064
{
1065
    dst->R = gl::floatToNormalized<int16_t>(src->red);
1066
    dst->G = gl::floatToNormalized<int16_t>(src->green);
1067
}
1068

1069
void R16G16S::average(R16G16S *dst, const R16G16S *src1, const R16G16S *src2)
1070
{
1071
    dst->R = gl::average(src1->R, src2->R);
1072
    dst->G = gl::average(src1->G, src2->G);
1073
}
1074

1075
void R16G16B16S::readColor(gl::ColorI *dst, const R16G16B16S *src)
1076
{
1077
    dst->red   = src->R;
1078
    dst->green = src->G;
1079
    dst->blue  = src->B;
1080
    dst->alpha = 1;
1081
}
1082

1083
void R16G16B16S::readColor(gl::ColorF *dst, const R16G16B16S *src)
1084
{
1085
    dst->red   = gl::normalizedToFloat(src->R);
1086
    dst->green = gl::normalizedToFloat(src->G);
1087
    dst->blue  = gl::normalizedToFloat(src->B);
1088
    dst->alpha = 1.0f;
1089
}
1090

1091
void R16G16B16S::writeColor(R16G16B16S *dst, const gl::ColorI *src)
1092
{
1093
    dst->R = static_cast<int16_t>(src->red);
1094
    dst->G = static_cast<int16_t>(src->green);
1095
    dst->B = static_cast<int16_t>(src->blue);
1096
}
1097

1098
void R16G16B16S::writeColor(R16G16B16S *dst, const gl::ColorF *src)
1099
{
1100
    dst->R = gl::floatToNormalized<int16_t>(src->red);
1101
    dst->G = gl::floatToNormalized<int16_t>(src->green);
1102
    dst->B = gl::floatToNormalized<int16_t>(src->blue);
1103
}
1104

1105
void R16G16B16S::average(R16G16B16S *dst, const R16G16B16S *src1, const R16G16B16S *src2)
1106
{
1107
    dst->R = gl::average(src1->R, src2->R);
1108
    dst->G = gl::average(src1->G, src2->G);
1109
    dst->B = gl::average(src1->B, src2->B);
1110
}
1111

1112
void R16G16B16A16S::readColor(gl::ColorI *dst, const R16G16B16A16S *src)
1113
{
1114
    dst->red   = src->R;
1115
    dst->green = src->G;
1116
    dst->blue  = src->B;
1117
    dst->alpha = src->A;
1118
}
1119

1120
void R16G16B16A16S::readColor(gl::ColorF *dst, const R16G16B16A16S *src)
1121
{
1122
    dst->red   = gl::normalizedToFloat(src->R);
1123
    dst->green = gl::normalizedToFloat(src->G);
1124
    dst->blue  = gl::normalizedToFloat(src->B);
1125
    dst->alpha = gl::normalizedToFloat(src->A);
1126
}
1127

1128
void R16G16B16A16S::writeColor(R16G16B16A16S *dst, const gl::ColorI *src)
1129
{
1130
    dst->R = static_cast<int16_t>(src->red);
1131
    dst->G = static_cast<int16_t>(src->green);
1132
    dst->B = static_cast<int16_t>(src->blue);
1133
    dst->A = static_cast<int16_t>(src->alpha);
1134
}
1135

1136
void R16G16B16A16S::writeColor(R16G16B16A16S *dst, const gl::ColorF *src)
1137
{
1138
    dst->R = gl::floatToNormalized<int16_t>(src->red);
1139
    dst->G = gl::floatToNormalized<int16_t>(src->green);
1140
    dst->B = gl::floatToNormalized<int16_t>(src->blue);
1141
    dst->A = gl::floatToNormalized<int16_t>(src->alpha);
1142
}
1143

1144
void R16G16B16A16S::average(R16G16B16A16S *dst,
1145
                            const R16G16B16A16S *src1,
1146
                            const R16G16B16A16S *src2)
1147
{
1148
    dst->R = gl::average(src1->R, src2->R);
1149
    dst->G = gl::average(src1->G, src2->G);
1150
    dst->B = gl::average(src1->B, src2->B);
1151
    dst->A = gl::average(src1->A, src2->A);
1152
}
1153

1154
void R32S::readColor(gl::ColorI *dst, const R32S *src)
1155
{
1156
    dst->red   = src->R;
1157
    dst->green = 0;
1158
    dst->blue  = 0;
1159
    dst->alpha = 1;
1160
}
1161

1162
void R32S::readColor(gl::ColorF *dst, const R32S *src)
1163
{
1164
    dst->red   = gl::normalizedToFloat(src->R);
1165
    dst->green = 0.0f;
1166
    dst->blue  = 0.0f;
1167
    dst->alpha = 1.0f;
1168
}
1169

1170
void R32S::writeColor(R32S *dst, const gl::ColorI *src)
1171
{
1172
    dst->R = static_cast<int32_t>(src->red);
1173
}
1174

1175
void R32S::writeColor(R32S *dst, const gl::ColorF *src)
1176
{
1177
    dst->R = gl::floatToNormalized<int32_t>(src->red);
1178
}
1179

1180
void R32S::average(R32S *dst, const R32S *src1, const R32S *src2)
1181
{
1182
    dst->R = gl::average(src1->R, src2->R);
1183
}
1184

1185
void R32G32S::readColor(gl::ColorI *dst, const R32G32S *src)
1186
{
1187
    dst->red   = src->R;
1188
    dst->green = src->G;
1189
    dst->blue  = 0;
1190
    dst->alpha = 1;
1191
}
1192

1193
void R32G32S::readColor(gl::ColorF *dst, const R32G32S *src)
1194
{
1195
    dst->red   = gl::normalizedToFloat(src->R);
1196
    dst->green = gl::normalizedToFloat(src->G);
1197
    dst->blue  = 0.0f;
1198
    dst->alpha = 1.0f;
1199
}
1200

1201
void R32G32S::writeColor(R32G32S *dst, const gl::ColorI *src)
1202
{
1203
    dst->R = static_cast<int32_t>(src->red);
1204
    dst->G = static_cast<int32_t>(src->green);
1205
}
1206

1207
void R32G32S::writeColor(R32G32S *dst, const gl::ColorF *src)
1208
{
1209
    dst->R = gl::floatToNormalized<int32_t>(src->red);
1210
    dst->G = gl::floatToNormalized<int32_t>(src->green);
1211
}
1212

1213
void R32G32S::average(R32G32S *dst, const R32G32S *src1, const R32G32S *src2)
1214
{
1215
    dst->R = gl::average(src1->R, src2->R);
1216
    dst->G = gl::average(src1->G, src2->G);
1217
}
1218

1219
void R32G32B32S::readColor(gl::ColorI *dst, const R32G32B32S *src)
1220
{
1221
    dst->red   = src->R;
1222
    dst->green = src->G;
1223
    dst->blue  = src->B;
1224
    dst->alpha = 1;
1225
}
1226

1227
void R32G32B32S::readColor(gl::ColorF *dst, const R32G32B32S *src)
1228
{
1229
    dst->red   = gl::normalizedToFloat(src->R);
1230
    dst->green = gl::normalizedToFloat(src->G);
1231
    dst->blue  = gl::normalizedToFloat(src->B);
1232
    dst->alpha = 1.0f;
1233
}
1234

1235
void R32G32B32S::writeColor(R32G32B32S *dst, const gl::ColorI *src)
1236
{
1237
    dst->R = static_cast<int32_t>(src->red);
1238
    dst->G = static_cast<int32_t>(src->green);
1239
    dst->B = static_cast<int32_t>(src->blue);
1240
}
1241

1242
void R32G32B32S::writeColor(R32G32B32S *dst, const gl::ColorF *src)
1243
{
1244
    dst->R = gl::floatToNormalized<int32_t>(src->red);
1245
    dst->G = gl::floatToNormalized<int32_t>(src->green);
1246
    dst->B = gl::floatToNormalized<int32_t>(src->blue);
1247
}
1248

1249
void R32G32B32S::average(R32G32B32S *dst, const R32G32B32S *src1, const R32G32B32S *src2)
1250
{
1251
    dst->R = gl::average(src1->R, src2->R);
1252
    dst->G = gl::average(src1->G, src2->G);
1253
    dst->B = gl::average(src1->B, src2->B);
1254
}
1255

1256
void R32G32B32A32S::readColor(gl::ColorI *dst, const R32G32B32A32S *src)
1257
{
1258
    dst->red   = src->R;
1259
    dst->green = src->G;
1260
    dst->blue  = src->B;
1261
    dst->alpha = src->A;
1262
}
1263

1264
void R32G32B32A32S::readColor(gl::ColorF *dst, const R32G32B32A32S *src)
1265
{
1266
    dst->red   = gl::normalizedToFloat(src->R);
1267
    dst->green = gl::normalizedToFloat(src->G);
1268
    dst->blue  = gl::normalizedToFloat(src->B);
1269
    dst->alpha = gl::normalizedToFloat(src->A);
1270
}
1271

1272
void R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorI *src)
1273
{
1274
    dst->R = static_cast<int32_t>(src->red);
1275
    dst->G = static_cast<int32_t>(src->green);
1276
    dst->B = static_cast<int32_t>(src->blue);
1277
    dst->A = static_cast<int32_t>(src->alpha);
1278
}
1279

1280
void R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorF *src)
1281
{
1282
    dst->R = gl::floatToNormalized<int32_t>(src->red);
1283
    dst->G = gl::floatToNormalized<int32_t>(src->green);
1284
    dst->B = gl::floatToNormalized<int32_t>(src->blue);
1285
    dst->A = gl::floatToNormalized<int32_t>(src->alpha);
1286
}
1287

1288
void R32G32B32A32S::average(R32G32B32A32S *dst,
1289
                            const R32G32B32A32S *src1,
1290
                            const R32G32B32A32S *src2)
1291
{
1292
    dst->R = gl::average(src1->R, src2->R);
1293
    dst->G = gl::average(src1->G, src2->G);
1294
    dst->B = gl::average(src1->B, src2->B);
1295
    dst->A = gl::average(src1->A, src2->A);
1296
}
1297

1298
void A16B16G16R16F::readColor(gl::ColorF *dst, const A16B16G16R16F *src)
1299
{
1300
    dst->red   = gl::float16ToFloat32(src->R);
1301
    dst->green = gl::float16ToFloat32(src->G);
1302
    dst->blue  = gl::float16ToFloat32(src->B);
1303
    dst->alpha = gl::float16ToFloat32(src->A);
1304
}
1305

1306
void A16B16G16R16F::writeColor(A16B16G16R16F *dst, const gl::ColorF *src)
1307
{
1308
    dst->R = gl::float32ToFloat16(src->red);
1309
    dst->G = gl::float32ToFloat16(src->green);
1310
    dst->B = gl::float32ToFloat16(src->blue);
1311
    dst->A = gl::float32ToFloat16(src->alpha);
1312
}
1313

1314
void A16B16G16R16F::average(A16B16G16R16F *dst,
1315
                            const A16B16G16R16F *src1,
1316
                            const A16B16G16R16F *src2)
1317
{
1318
    dst->R = gl::averageHalfFloat(src1->R, src2->R);
1319
    dst->G = gl::averageHalfFloat(src1->G, src2->G);
1320
    dst->B = gl::averageHalfFloat(src1->B, src2->B);
1321
    dst->A = gl::averageHalfFloat(src1->A, src2->A);
1322
}
1323

1324
void R16G16B16A16F::readColor(gl::ColorF *dst, const R16G16B16A16F *src)
1325
{
1326
    dst->red   = gl::float16ToFloat32(src->R);
1327
    dst->green = gl::float16ToFloat32(src->G);
1328
    dst->blue  = gl::float16ToFloat32(src->B);
1329
    dst->alpha = gl::float16ToFloat32(src->A);
1330
}
1331

1332
void R16G16B16A16F::writeColor(R16G16B16A16F *dst, const gl::ColorF *src)
1333
{
1334
    dst->R = gl::float32ToFloat16(src->red);
1335
    dst->G = gl::float32ToFloat16(src->green);
1336
    dst->B = gl::float32ToFloat16(src->blue);
1337
    dst->A = gl::float32ToFloat16(src->alpha);
1338
}
1339

1340
void R16G16B16A16F::average(R16G16B16A16F *dst,
1341
                            const R16G16B16A16F *src1,
1342
                            const R16G16B16A16F *src2)
1343
{
1344
    dst->R = gl::averageHalfFloat(src1->R, src2->R);
1345
    dst->G = gl::averageHalfFloat(src1->G, src2->G);
1346
    dst->B = gl::averageHalfFloat(src1->B, src2->B);
1347
    dst->A = gl::averageHalfFloat(src1->A, src2->A);
1348
}
1349

1350
void R16F::readColor(gl::ColorF *dst, const R16F *src)
1351
{
1352
    dst->red   = gl::float16ToFloat32(src->R);
1353
    dst->green = 0.0f;
1354
    dst->blue  = 0.0f;
1355
    dst->alpha = 1.0f;
1356
}
1357

1358
void R16F::writeColor(R16F *dst, const gl::ColorF *src)
1359
{
1360
    dst->R = gl::float32ToFloat16(src->red);
1361
}
1362

1363
void R16F::average(R16F *dst, const R16F *src1, const R16F *src2)
1364
{
1365
    dst->R = gl::averageHalfFloat(src1->R, src2->R);
1366
}
1367

1368
void A16F::readColor(gl::ColorF *dst, const A16F *src)
1369
{
1370
    dst->red   = 0.0f;
1371
    dst->green = 0.0f;
1372
    dst->blue  = 0.0f;
1373
    dst->alpha = gl::float16ToFloat32(src->A);
1374
}
1375

1376
void A16F::writeColor(A16F *dst, const gl::ColorF *src)
1377
{
1378
    dst->A = gl::float32ToFloat16(src->alpha);
1379
}
1380

1381
void A16F::average(A16F *dst, const A16F *src1, const A16F *src2)
1382
{
1383
    dst->A = gl::averageHalfFloat(src1->A, src2->A);
1384
}
1385

1386
void L16F::readColor(gl::ColorF *dst, const L16F *src)
1387
{
1388
    float lum  = gl::float16ToFloat32(src->L);
1389
    dst->red   = lum;
1390
    dst->green = lum;
1391
    dst->blue  = lum;
1392
    dst->alpha = 1.0f;
1393
}
1394

1395
void L16F::writeColor(L16F *dst, const gl::ColorF *src)
1396
{
1397
    dst->L = gl::float32ToFloat16(src->red);
1398
}
1399

1400
void L16F::average(L16F *dst, const L16F *src1, const L16F *src2)
1401
{
1402
    dst->L = gl::averageHalfFloat(src1->L, src2->L);
1403
}
1404

1405
void L16A16F::readColor(gl::ColorF *dst, const L16A16F *src)
1406
{
1407
    float lum  = gl::float16ToFloat32(src->L);
1408
    dst->red   = lum;
1409
    dst->green = lum;
1410
    dst->blue  = lum;
1411
    dst->alpha = gl::float16ToFloat32(src->A);
1412
}
1413

1414
void L16A16F::writeColor(L16A16F *dst, const gl::ColorF *src)
1415
{
1416
    dst->L = gl::float32ToFloat16(src->red);
1417
    dst->A = gl::float32ToFloat16(src->alpha);
1418
}
1419

1420
void L16A16F::average(L16A16F *dst, const L16A16F *src1, const L16A16F *src2)
1421
{
1422
    dst->L = gl::averageHalfFloat(src1->L, src2->L);
1423
    dst->A = gl::averageHalfFloat(src1->A, src2->A);
1424
}
1425

1426
void R16G16F::readColor(gl::ColorF *dst, const R16G16F *src)
1427
{
1428
    dst->red   = gl::float16ToFloat32(src->R);
1429
    dst->green = gl::float16ToFloat32(src->G);
1430
    dst->blue  = 0.0f;
1431
    dst->alpha = 1.0f;
1432
}
1433

1434
void R16G16F::writeColor(R16G16F *dst, const gl::ColorF *src)
1435
{
1436
    dst->R = gl::float32ToFloat16(src->red);
1437
    dst->G = gl::float32ToFloat16(src->green);
1438
}
1439

1440
void R16G16F::average(R16G16F *dst, const R16G16F *src1, const R16G16F *src2)
1441
{
1442
    dst->R = gl::averageHalfFloat(src1->R, src2->R);
1443
    dst->G = gl::averageHalfFloat(src1->G, src2->G);
1444
}
1445

1446
void R16G16B16F::readColor(gl::ColorF *dst, const R16G16B16F *src)
1447
{
1448
    dst->red   = gl::float16ToFloat32(src->R);
1449
    dst->green = gl::float16ToFloat32(src->G);
1450
    dst->blue  = gl::float16ToFloat32(src->B);
1451
    dst->alpha = 1.0f;
1452
}
1453

1454
void R16G16B16F::writeColor(R16G16B16F *dst, const gl::ColorF *src)
1455
{
1456
    dst->R = gl::float32ToFloat16(src->red);
1457
    dst->G = gl::float32ToFloat16(src->green);
1458
    dst->B = gl::float32ToFloat16(src->blue);
1459
}
1460

1461
void R16G16B16F::average(R16G16B16F *dst, const R16G16B16F *src1, const R16G16B16F *src2)
1462
{
1463
    dst->R = gl::averageHalfFloat(src1->R, src2->R);
1464
    dst->G = gl::averageHalfFloat(src1->G, src2->G);
1465
    dst->B = gl::averageHalfFloat(src1->B, src2->B);
1466
}
1467

1468
void A32B32G32R32F::readColor(gl::ColorF *dst, const A32B32G32R32F *src)
1469
{
1470
    dst->red   = src->R;
1471
    dst->green = src->G;
1472
    dst->blue  = src->B;
1473
    dst->alpha = src->A;
1474
}
1475

1476
void A32B32G32R32F::writeColor(A32B32G32R32F *dst, const gl::ColorF *src)
1477
{
1478
    dst->R = src->red;
1479
    dst->G = src->green;
1480
    dst->B = src->blue;
1481
    dst->A = src->alpha;
1482
}
1483

1484
void A32B32G32R32F::average(A32B32G32R32F *dst,
1485
                            const A32B32G32R32F *src1,
1486
                            const A32B32G32R32F *src2)
1487
{
1488
    dst->R = gl::average(src1->R, src2->R);
1489
    dst->G = gl::average(src1->G, src2->G);
1490
    dst->B = gl::average(src1->B, src2->B);
1491
    dst->A = gl::average(src1->A, src2->A);
1492
}
1493

1494
void R32G32B32A32F::readColor(gl::ColorF *dst, const R32G32B32A32F *src)
1495
{
1496
    dst->red   = src->R;
1497
    dst->green = src->G;
1498
    dst->blue  = src->B;
1499
    dst->alpha = src->A;
1500
}
1501

1502
void R32G32B32A32F::writeColor(R32G32B32A32F *dst, const gl::ColorF *src)
1503
{
1504
    dst->R = src->red;
1505
    dst->G = src->green;
1506
    dst->B = src->blue;
1507
    dst->A = src->alpha;
1508
}
1509

1510
void R32G32B32A32F::average(R32G32B32A32F *dst,
1511
                            const R32G32B32A32F *src1,
1512
                            const R32G32B32A32F *src2)
1513
{
1514
    dst->R = gl::average(src1->R, src2->R);
1515
    dst->G = gl::average(src1->G, src2->G);
1516
    dst->B = gl::average(src1->B, src2->B);
1517
    dst->A = gl::average(src1->A, src2->A);
1518
}
1519

1520
void R32F::readColor(gl::ColorF *dst, const R32F *src)
1521
{
1522
    dst->red   = src->R;
1523
    dst->green = 0.0f;
1524
    dst->blue  = 0.0f;
1525
    dst->alpha = 1.0f;
1526
}
1527

1528
void R32F::writeColor(R32F *dst, const gl::ColorF *src)
1529
{
1530
    dst->R = src->red;
1531
}
1532

1533
void R32F::average(R32F *dst, const R32F *src1, const R32F *src2)
1534
{
1535
    dst->R = gl::average(src1->R, src2->R);
1536
}
1537

1538
void A32F::readColor(gl::ColorF *dst, const A32F *src)
1539
{
1540
    dst->red   = 0.0f;
1541
    dst->green = 0.0f;
1542
    dst->blue  = 0.0f;
1543
    dst->alpha = src->A;
1544
}
1545

1546
void A32F::writeColor(A32F *dst, const gl::ColorF *src)
1547
{
1548
    dst->A = src->alpha;
1549
}
1550

1551
void A32F::average(A32F *dst, const A32F *src1, const A32F *src2)
1552
{
1553
    dst->A = gl::average(src1->A, src2->A);
1554
}
1555

1556
void L32F::readColor(gl::ColorF *dst, const L32F *src)
1557
{
1558
    dst->red   = src->L;
1559
    dst->green = src->L;
1560
    dst->blue  = src->L;
1561
    dst->alpha = 1.0f;
1562
}
1563

1564
void L32F::writeColor(L32F *dst, const gl::ColorF *src)
1565
{
1566
    dst->L = src->red;
1567
}
1568

1569
void L32F::average(L32F *dst, const L32F *src1, const L32F *src2)
1570
{
1571
    dst->L = gl::average(src1->L, src2->L);
1572
}
1573

1574
void L32A32F::readColor(gl::ColorF *dst, const L32A32F *src)
1575
{
1576
    dst->red   = src->L;
1577
    dst->green = src->L;
1578
    dst->blue  = src->L;
1579
    dst->alpha = src->A;
1580
}
1581

1582
void L32A32F::writeColor(L32A32F *dst, const gl::ColorF *src)
1583
{
1584
    dst->L = src->red;
1585
    dst->A = src->alpha;
1586
}
1587

1588
void L32A32F::average(L32A32F *dst, const L32A32F *src1, const L32A32F *src2)
1589
{
1590
    dst->L = gl::average(src1->L, src2->L);
1591
    dst->A = gl::average(src1->A, src2->A);
1592
}
1593

1594
void R32G32F::readColor(gl::ColorF *dst, const R32G32F *src)
1595
{
1596
    dst->red   = src->R;
1597
    dst->green = src->G;
1598
    dst->blue  = 0.0f;
1599
    dst->alpha = 1.0f;
1600
}
1601

1602
void R32G32F::writeColor(R32G32F *dst, const gl::ColorF *src)
1603
{
1604
    dst->R = src->red;
1605
    dst->G = src->green;
1606
}
1607

1608
void R32G32F::average(R32G32F *dst, const R32G32F *src1, const R32G32F *src2)
1609
{
1610
    dst->R = gl::average(src1->R, src2->R);
1611
    dst->G = gl::average(src1->G, src2->G);
1612
}
1613

1614
void R32G32B32F::readColor(gl::ColorF *dst, const R32G32B32F *src)
1615
{
1616
    dst->red   = src->R;
1617
    dst->green = src->G;
1618
    dst->blue  = src->B;
1619
    dst->alpha = 1.0f;
1620
}
1621

1622
void R32G32B32F::writeColor(R32G32B32F *dst, const gl::ColorF *src)
1623
{
1624
    dst->R = src->red;
1625
    dst->G = src->green;
1626
    dst->B = src->blue;
1627
}
1628

1629
void R32G32B32F::average(R32G32B32F *dst, const R32G32B32F *src1, const R32G32B32F *src2)
1630
{
1631
    dst->R = gl::average(src1->R, src2->R);
1632
    dst->G = gl::average(src1->G, src2->G);
1633
    dst->B = gl::average(src1->B, src2->B);
1634
}
1635

1636
void R10G10B10A2::readColor(gl::ColorUI *dst, const R10G10B10A2 *src)
1637
{
1638
    dst->red   = src->R;
1639
    dst->green = src->G;
1640
    dst->blue  = src->B;
1641
    dst->alpha = src->A;
1642
}
1643

1644
void R10G10B10A2::readColor(gl::ColorF *dst, const R10G10B10A2 *src)
1645
{
1646
    dst->red   = gl::normalizedToFloat<10>(src->R);
1647
    dst->green = gl::normalizedToFloat<10>(src->G);
1648
    dst->blue  = gl::normalizedToFloat<10>(src->B);
1649
    dst->alpha = gl::normalizedToFloat<2>(src->A);
1650
}
1651

1652
void R10G10B10A2::writeColor(R10G10B10A2 *dst, const gl::ColorUI *src)
1653
{
1654
    dst->R = static_cast<uint32_t>(src->red);
1655
    dst->G = static_cast<uint32_t>(src->green);
1656
    dst->B = static_cast<uint32_t>(src->blue);
1657
    dst->A = static_cast<uint32_t>(src->alpha);
1658
}
1659

1660
void R10G10B10A2::writeColor(R10G10B10A2 *dst, const gl::ColorF *src)
1661
{
1662
    dst->R = gl::floatToNormalized<10, uint32_t>(src->red);
1663
    dst->G = gl::floatToNormalized<10, uint32_t>(src->green);
1664
    dst->B = gl::floatToNormalized<10, uint32_t>(src->blue);
1665
    dst->A = gl::floatToNormalized<2, uint32_t>(src->alpha);
1666
}
1667

1668
void R10G10B10A2::average(R10G10B10A2 *dst, const R10G10B10A2 *src1, const R10G10B10A2 *src2)
1669
{
1670
    dst->R = gl::average(src1->R, src2->R);
1671
    dst->G = gl::average(src1->G, src2->G);
1672
    dst->B = gl::average(src1->B, src2->B);
1673
    dst->A = gl::average(src1->A, src2->A);
1674
}
1675

1676
void R10G10B10A2S::readColor(gl::ColorI *dst, const R10G10B10A2S *src)
1677
{
1678
    dst->red   = src->R;
1679
    dst->green = src->G;
1680
    dst->blue  = src->B;
1681
    dst->alpha = src->A;
1682
}
1683

1684
void R10G10B10A2S::readColor(gl::ColorF *dst, const R10G10B10A2S *src)
1685
{
1686
    dst->red   = gl::normalizedToFloat<10>(src->R);
1687
    dst->green = gl::normalizedToFloat<10>(src->G);
1688
    dst->blue  = gl::normalizedToFloat<10>(src->B);
1689
    dst->alpha = gl::normalizedToFloat<2>(src->A);
1690
}
1691

1692
void R10G10B10A2S::writeColor(R10G10B10A2S *dst, const gl::ColorI *src)
1693
{
1694
    dst->R = static_cast<int32_t>(src->red);
1695
    dst->G = static_cast<int32_t>(src->green);
1696
    dst->B = static_cast<int32_t>(src->blue);
1697
    dst->A = static_cast<int32_t>(src->alpha);
1698
}
1699

1700
void R10G10B10A2S::writeColor(R10G10B10A2S *dst, const gl::ColorF *src)
1701
{
1702
    dst->R = gl::floatToNormalized<10, int32_t>(src->red);
1703
    dst->G = gl::floatToNormalized<10, int32_t>(src->green);
1704
    dst->B = gl::floatToNormalized<10, int32_t>(src->blue);
1705
    dst->A = gl::floatToNormalized<2, int32_t>(src->alpha);
1706
}
1707

1708
void R10G10B10A2S::average(R10G10B10A2S *dst, const R10G10B10A2S *src1, const R10G10B10A2S *src2)
1709
{
1710
    dst->R = gl::average(src1->R, src2->R);
1711
    dst->G = gl::average(src1->G, src2->G);
1712
    dst->B = gl::average(src1->B, src2->B);
1713
    dst->A = gl::average(src1->A, src2->A);
1714
}
1715

1716
void R10G10B10X2::readColor(gl::ColorUI *dst, const R10G10B10X2 *src)
1717
{
1718
    dst->red   = src->R;
1719
    dst->green = src->G;
1720
    dst->blue  = src->B;
1721
    dst->alpha = 0x3;
1722
}
1723

1724
void R10G10B10X2::readColor(gl::ColorF *dst, const R10G10B10X2 *src)
1725
{
1726
    dst->red   = gl::normalizedToFloat<10>(src->R);
1727
    dst->green = gl::normalizedToFloat<10>(src->G);
1728
    dst->blue  = gl::normalizedToFloat<10>(src->B);
1729
    dst->alpha = 1.0f;
1730
}
1731

1732
void R10G10B10X2::writeColor(R10G10B10X2 *dst, const gl::ColorUI *src)
1733
{
1734
    dst->R = static_cast<uint32_t>(src->red);
1735
    dst->G = static_cast<uint32_t>(src->green);
1736
    dst->B = static_cast<uint32_t>(src->blue);
1737
}
1738

1739
void R10G10B10X2::writeColor(R10G10B10X2 *dst, const gl::ColorF *src)
1740
{
1741
    dst->R = gl::floatToNormalized<10, uint32_t>(src->red);
1742
    dst->G = gl::floatToNormalized<10, uint32_t>(src->green);
1743
    dst->B = gl::floatToNormalized<10, uint32_t>(src->blue);
1744
}
1745

1746
void R10G10B10X2::average(R10G10B10X2 *dst, const R10G10B10X2 *src1, const R10G10B10X2 *src2)
1747
{
1748
    dst->R = gl::average(src1->R, src2->R);
1749
    dst->G = gl::average(src1->G, src2->G);
1750
    dst->B = gl::average(src1->B, src2->B);
1751
}
1752

1753
void B10G10R10A2::readColor(gl::ColorUI *dst, const B10G10R10A2 *src)
1754
{
1755
    dst->red   = src->R;
1756
    dst->green = src->G;
1757
    dst->blue  = src->B;
1758
    dst->alpha = src->A;
1759
}
1760

1761
void B10G10R10A2::readColor(gl::ColorF *dst, const B10G10R10A2 *src)
1762
{
1763
    dst->red   = gl::normalizedToFloat<10>(src->R);
1764
    dst->green = gl::normalizedToFloat<10>(src->G);
1765
    dst->blue  = gl::normalizedToFloat<10>(src->B);
1766
    dst->alpha = gl::normalizedToFloat<2>(src->A);
1767
}
1768

1769
void B10G10R10A2::writeColor(B10G10R10A2 *dst, const gl::ColorUI *src)
1770
{
1771
    dst->R = static_cast<uint32_t>(src->red);
1772
    dst->G = static_cast<uint32_t>(src->green);
1773
    dst->B = static_cast<uint32_t>(src->blue);
1774
    dst->A = static_cast<uint32_t>(src->alpha);
1775
}
1776

1777
void B10G10R10A2::writeColor(B10G10R10A2 *dst, const gl::ColorF *src)
1778
{
1779
    dst->R = gl::floatToNormalized<10, uint32_t>(src->red);
1780
    dst->G = gl::floatToNormalized<10, uint32_t>(src->green);
1781
    dst->B = gl::floatToNormalized<10, uint32_t>(src->blue);
1782
    dst->A = gl::floatToNormalized<2, uint32_t>(src->alpha);
1783
}
1784

1785
void B10G10R10A2::average(B10G10R10A2 *dst, const B10G10R10A2 *src1, const B10G10R10A2 *src2)
1786
{
1787
    dst->R = gl::average(src1->R, src2->R);
1788
    dst->G = gl::average(src1->G, src2->G);
1789
    dst->B = gl::average(src1->B, src2->B);
1790
    dst->A = gl::average(src1->A, src2->A);
1791
}
1792

1793
void R9G9B9E5::readColor(gl::ColorF *dst, const R9G9B9E5 *src)
1794
{
1795
    gl::convert999E5toRGBFloats(gl::bitCast<uint32_t>(*src), &dst->red, &dst->green, &dst->blue);
1796
    dst->alpha = 1.0f;
1797
}
1798

1799
void R9G9B9E5::writeColor(R9G9B9E5 *dst, const gl::ColorF *src)
1800
{
1801
    *reinterpret_cast<uint32_t *>(dst) =
1802
        gl::convertRGBFloatsTo999E5(src->red, src->green, src->blue);
1803
}
1804

1805
void R9G9B9E5::average(R9G9B9E5 *dst, const R9G9B9E5 *src1, const R9G9B9E5 *src2)
1806
{
1807
    float r1, g1, b1;
1808
    gl::convert999E5toRGBFloats(*reinterpret_cast<const uint32_t *>(src1), &r1, &g1, &b1);
1809

1810
    float r2, g2, b2;
1811
    gl::convert999E5toRGBFloats(*reinterpret_cast<const uint32_t *>(src2), &r2, &g2, &b2);
1812

1813
    *reinterpret_cast<uint32_t *>(dst) =
1814
        gl::convertRGBFloatsTo999E5(gl::average(r1, r2), gl::average(g1, g2), gl::average(b1, b2));
1815
}
1816

1817
void R11G11B10F::readColor(gl::ColorF *dst, const R11G11B10F *src)
1818
{
1819
    dst->red   = gl::float11ToFloat32(src->R);
1820
    dst->green = gl::float11ToFloat32(src->G);
1821
    dst->blue  = gl::float10ToFloat32(src->B);
1822
    dst->alpha = 1.0f;
1823
}
1824

1825
void R11G11B10F::writeColor(R11G11B10F *dst, const gl::ColorF *src)
1826
{
1827
    dst->R = gl::float32ToFloat11(src->red);
1828
    dst->G = gl::float32ToFloat11(src->green);
1829
    dst->B = gl::float32ToFloat10(src->blue);
1830
}
1831

1832
void R11G11B10F::average(R11G11B10F *dst, const R11G11B10F *src1, const R11G11B10F *src2)
1833
{
1834
    dst->R = gl::averageFloat11(src1->R, src2->R);
1835
    dst->G = gl::averageFloat11(src1->G, src2->G);
1836
    dst->B = gl::averageFloat10(src1->B, src2->B);
1837
}
1838

1839
void D24S8::ReadDepthStencil(DepthStencil *dst, const D24S8 *src)
1840
{
1841
    dst->depth   = gl::normalizedToFloat<24>(src->D);
1842
    dst->stencil = src->S;
1843
}
1844

1845
void D24S8::WriteDepthStencil(D24S8 *dst, const DepthStencil *src)
1846
{
1847
    dst->D = gl::floatToNormalized<24, uint32_t>(static_cast<float>(src->depth));
1848
    dst->S = src->stencil & 0xFF;
1849
}
1850

1851
void S8::ReadDepthStencil(DepthStencil *dst, const S8 *src)
1852
{
1853
    dst->depth   = 0;
1854
    dst->stencil = src->S;
1855
}
1856

1857
void S8::WriteDepthStencil(S8 *dst, const DepthStencil *src)
1858
{
1859
    dst->S = src->stencil & 0xFF;
1860
}
1861

1862
void D16::ReadDepthStencil(DepthStencil *dst, const D16 *src)
1863
{
1864
    dst->depth   = gl::normalizedToFloat(src->D);
1865
    dst->stencil = 0;
1866
}
1867

1868
void D16::WriteDepthStencil(D16 *dst, const DepthStencil *src)
1869
{
1870
    dst->D = gl::floatToNormalized<uint16_t>(static_cast<float>(src->depth));
1871
}
1872

1873
void D24X8::ReadDepthStencil(DepthStencil *dst, const D24X8 *src)
1874
{
1875
    dst->depth = gl::normalizedToFloat<24>(src->D & 0x00ffffff);
1876
}
1877

1878
void D24X8::WriteDepthStencil(D24X8 *dst, const DepthStencil *src)
1879
{
1880
    dst->D = gl::floatToNormalized<24, uint32_t>(static_cast<float>(src->depth));
1881
}
1882

1883
void D32F::ReadDepthStencil(DepthStencil *dst, const D32F *src)
1884
{
1885
    dst->depth = src->D;
1886
}
1887

1888
void D32F::WriteDepthStencil(D32F *dst, const DepthStencil *src)
1889
{
1890
    dst->D = static_cast<float>(src->depth);
1891
}
1892

1893
void D32::ReadDepthStencil(DepthStencil *dst, const D32 *src)
1894
{
1895
    dst->depth   = gl::normalizedToFloat(src->D);
1896
    dst->stencil = 0;
1897
}
1898

1899
void D32::WriteDepthStencil(D32 *dst, const DepthStencil *src)
1900
{
1901
    dst->D = gl::floatToNormalized<uint32_t>(static_cast<float>(src->depth));
1902
}
1903

1904
void D32FS8X24::ReadDepthStencil(DepthStencil *dst, const D32FS8X24 *src)
1905
{
1906
    dst->depth   = src->D;
1907
    dst->stencil = src->S;
1908
}
1909

1910
void D32FS8X24::WriteDepthStencil(D32FS8X24 *dst, const DepthStencil *src)
1911
{
1912
    dst->D = static_cast<float>(src->depth);
1913
    dst->S = src->stencil & 0xFF;
1914
}
1915
}  // namespace angle
1916

1917
Product

Resources

Company
