1//
2// Copyright (c) 2013 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.h: Defines image format types with functions for mip generation
8// and copying.
9
10#ifndef LIBGLESV2_RENDERER_IMAGEFORMATS_H_
11#define LIBGLESV2_RENDERER_IMAGEFORMATS_H_
12
13#include "common/mathutil.h"
14
15namespace rx
16{
17
18// Several structures share functionality for reading, writing or mipmapping but the layout
19// must match the texture format which the structure represents. If collapsing or typedefing
20// structs in this header, make sure the functionality and memory layout is exactly the same.
21
22struct L8
23{
24    unsigned char L;
25
26    static void readColor(gl::ColorF *dst, const L8 *src)
27    {
28        const float lum = gl::normalizedToFloat(src->L);
29        dst->red   = lum;
30        dst->green = lum;
31        dst->blue  = lum;
32        dst->alpha = 1.0f;
33    }
34
35    static void writeColor(L8 *dst, const gl::ColorF *src)
36    {
37        dst->L = gl::floatToNormalized<unsigned char>((src->red + src->green + src->blue) / 3.0f);
38    }
39
40    static void average(L8 *dst, const L8 *src1, const L8 *src2)
41    {
42        dst->L = gl::average(src1->L, src2->L);
43    }
44};
45
46struct R8
47{
48    unsigned char R;
49
50    static void readColor(gl::ColorF *dst, const R8 *src)
51    {
52        dst->red   = gl::normalizedToFloat(src->R);
53        dst->green = 0.0f;
54        dst->blue  = 0.0f;
55        dst->alpha = 1.0f;
56    }
57
58    static void readColor(gl::ColorUI *dst, const R8 *src)
59    {
60        dst->red   = src->R;
61        dst->green = 0;
62        dst->blue  = 0;
63        dst->alpha = 1;
64    }
65
66    static void writeColor(R8 *dst, const gl::ColorF *src)
67    {
68        dst->R = gl::floatToNormalized<unsigned char>(src->red);
69    }
70
71    static void writeColor(R8 *dst, const gl::ColorUI *src)
72    {
73        dst->R = static_cast<unsigned char>(src->red);
74    }
75
76    static void average(R8 *dst, const R8 *src1, const R8 *src2)
77    {
78        dst->R = gl::average(src1->R, src2->R);
79    }
80};
81
82struct A8
83{
84    unsigned char A;
85
86    static void readColor(gl::ColorF *dst, const A8 *src)
87    {
88        dst->red   = 0.0f;
89        dst->green = 0.0f;
90        dst->blue  = 0.0f;
91        dst->alpha = gl::normalizedToFloat(src->A);
92    }
93
94    static void writeColor(A8 *dst, const gl::ColorF *src)
95    {
96        dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
97    }
98
99    static void average(A8 *dst, const A8 *src1, const A8 *src2)
100    {
101        dst->A = gl::average(src1->A, src2->A);
102    }
103};
104
105struct L8A8
106{
107    unsigned char L;
108    unsigned char A;
109
110    static void readColor(gl::ColorF *dst, const L8A8 *src)
111    {
112        const float lum = gl::normalizedToFloat(src->L);
113        dst->red   = lum;
114        dst->green = lum;
115        dst->blue  = lum;
116        dst->alpha = gl::normalizedToFloat(src->A);
117    }
118
119    static void writeColor(L8A8 *dst, const gl::ColorF *src)
120    {
121        dst->L = gl::floatToNormalized<unsigned char>((src->red + src->green + src->blue) / 3.0f);
122        dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
123    }
124
125    static void average(L8A8 *dst, const L8A8 *src1, const L8A8 *src2)
126    {
127        *(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2);
128    }
129};
130
131struct A8L8
132{
133    unsigned char A;
134    unsigned char L;
135
136    static void readColor(gl::ColorF *dst, const A8L8 *src)
137    {
138        const float lum = gl::normalizedToFloat(src->L);
139        dst->red   = lum;
140        dst->green = lum;
141        dst->blue  = lum;
142        dst->alpha = gl::normalizedToFloat(src->A);
143    }
144
145    static void writeColor(A8L8 *dst, const gl::ColorF *src)
146    {
147        dst->L = gl::floatToNormalized<unsigned char>((src->red + src->green + src->blue) / 3.0f);
148        dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
149    }
150
151    static void average(A8L8 *dst, const A8L8 *src1, const A8L8 *src2)
152    {
153        *(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2);
154    }
155};
156
157struct R8G8
158{
159    unsigned char R;
160    unsigned char G;
161
162    static void readColor(gl::ColorF *dst, const R8G8 *src)
163    {
164        dst->red   = gl::normalizedToFloat(src->R);
165        dst->green = gl::normalizedToFloat(src->G);
166        dst->blue  = 0.0f;
167        dst->alpha = 1.0f;
168    }
169
170    static void readColor(gl::ColorUI *dst, const R8G8 *src)
171    {
172        dst->red   = src->R;
173        dst->green = src->G;
174        dst->blue  = 0;
175        dst->alpha = 1;
176    }
177
178    static void writeColor(R8G8 *dst, const gl::ColorF *src)
179    {
180        dst->R = gl::floatToNormalized<unsigned char>(src->red);
181        dst->G = gl::floatToNormalized<unsigned char>(src->green);
182    }
183
184    static void writeColor(R8G8 *dst, const gl::ColorUI *src)
185    {
186        dst->R = static_cast<unsigned char>(src->red);
187        dst->G = static_cast<unsigned char>(src->green);
188    }
189
190    static void average(R8G8 *dst, const R8G8 *src1, const R8G8 *src2)
191    {
192        *(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2);
193    }
194};
195
196struct R8G8B8
197{
198    unsigned char R;
199    unsigned char G;
200    unsigned char B;
201
202    static void readColor(gl::ColorF *dst, const R8G8B8 *src)
203    {
204        dst->red   = gl::normalizedToFloat(src->R);
205        dst->green = gl::normalizedToFloat(src->G);
206        dst->blue  = gl::normalizedToFloat(src->B);
207        dst->alpha = 1.0f;
208    }
209
210    static void readColor(gl::ColorUI *dst, const R8G8B8 *src)
211    {
212        dst->red   = src->R;
213        dst->green = src->G;
214        dst->blue  = src->G;
215        dst->alpha = 1;
216    }
217
218    static void writeColor(R8G8B8 *dst, const gl::ColorF *src)
219    {
220        dst->R = gl::floatToNormalized<unsigned char>(src->red);
221        dst->G = gl::floatToNormalized<unsigned char>(src->green);
222        dst->B = gl::floatToNormalized<unsigned char>(src->blue);
223    }
224
225    static void writeColor(R8G8B8 *dst, const gl::ColorUI *src)
226    {
227        dst->R = static_cast<unsigned char>(src->red);
228        dst->G = static_cast<unsigned char>(src->green);
229        dst->B = static_cast<unsigned char>(src->blue);
230    }
231
232    static void average(R8G8B8 *dst, const R8G8B8 *src1, const R8G8B8 *src2)
233    {
234        dst->R = gl::average(src1->R, src2->R);
235        dst->G = gl::average(src1->G, src2->G);
236        dst->B = gl::average(src1->B, src2->B);
237    }
238};
239
240struct B8G8R8
241{
242    unsigned char B;
243    unsigned char G;
244    unsigned char R;
245
246    static void readColor(gl::ColorF *dst, const B8G8R8 *src)
247    {
248        dst->red   = gl::normalizedToFloat(src->R);
249        dst->green = gl::normalizedToFloat(src->G);
250        dst->blue  = gl::normalizedToFloat(src->B);
251        dst->alpha = 1.0f;
252    }
253
254    static void readColor(gl::ColorUI *dst, const B8G8R8 *src)
255    {
256        dst->red   = src->R;
257        dst->green = src->G;
258        dst->blue  = src->G;
259        dst->alpha = 1;
260    }
261
262    static void writeColor(B8G8R8 *dst, const gl::ColorF *src)
263    {
264        dst->R = gl::floatToNormalized<unsigned char>(src->red);
265        dst->G = gl::floatToNormalized<unsigned char>(src->green);
266        dst->B = gl::floatToNormalized<unsigned char>(src->blue);
267    }
268
269    static void writeColor(B8G8R8 *dst, const gl::ColorUI *src)
270    {
271        dst->R = static_cast<unsigned char>(src->red);
272        dst->G = static_cast<unsigned char>(src->green);
273        dst->B = static_cast<unsigned char>(src->blue);
274    }
275
276    static void average(B8G8R8 *dst, const B8G8R8 *src1, const B8G8R8 *src2)
277    {
278        dst->R = gl::average(src1->R, src2->R);
279        dst->G = gl::average(src1->G, src2->G);
280        dst->B = gl::average(src1->B, src2->B);
281    }
282};
283
284struct R5G6B5
285{
286    unsigned short RGB;
287
288    static void readColor(gl::ColorF *dst, const R5G6B5 *src)
289    {
290        dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->RGB));
291        dst->green = gl::normalizedToFloat<6>(gl::getShiftedData<6,  5>(src->RGB));
292        dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5,  0>(src->RGB));
293        dst->alpha = 1.0f;
294    }
295
296    static void writeColor(R5G6B5 *dst, const gl::ColorF *src)
297    {
298        dst->RGB = gl::shiftData<5, 11>(gl::floatToNormalized<5, unsigned short>(src->red))   |
299                   gl::shiftData<6,  5>(gl::floatToNormalized<6, unsigned short>(src->green)) |
300                   gl::shiftData<5,  0>(gl::floatToNormalized<5, unsigned short>(src->blue));
301    }
302
303    static void average(R5G6B5 *dst, const R5G6B5 *src1, const R5G6B5 *src2)
304    {
305        dst->RGB = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->RGB), gl::getShiftedData<5, 11>(src2->RGB))) |
306                   gl::shiftData<6,  5>(gl::average(gl::getShiftedData<6,  5>(src1->RGB), gl::getShiftedData<6,  5>(src2->RGB))) |
307                   gl::shiftData<5,  0>(gl::average(gl::getShiftedData<5,  0>(src1->RGB), gl::getShiftedData<5,  0>(src2->RGB)));
308    }
309};
310
311struct A8R8G8B8
312{
313    unsigned char A;
314    unsigned char R;
315    unsigned char G;
316    unsigned char B;
317
318    static void readColor(gl::ColorF *dst, const A8R8G8B8 *src)
319    {
320        dst->red   = gl::normalizedToFloat(src->R);
321        dst->green = gl::normalizedToFloat(src->G);
322        dst->blue  = gl::normalizedToFloat(src->B);
323        dst->alpha = gl::normalizedToFloat(src->A);
324    }
325
326    static void readColor(gl::ColorUI *dst, const A8R8G8B8 *src)
327    {
328        dst->red   = src->R;
329        dst->green = src->G;
330        dst->blue  = src->B;
331        dst->alpha = src->A;
332    }
333
334    static void writeColor(A8R8G8B8 *dst, const gl::ColorF *src)
335    {
336        dst->R = gl::floatToNormalized<unsigned char>(src->red);
337        dst->G = gl::floatToNormalized<unsigned char>(src->green);
338        dst->B = gl::floatToNormalized<unsigned char>(src->blue);
339        dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
340    }
341
342    static void writeColor(A8R8G8B8 *dst, const gl::ColorUI *src)
343    {
344        dst->R = static_cast<unsigned char>(src->red);
345        dst->G = static_cast<unsigned char>(src->green);
346        dst->B = static_cast<unsigned char>(src->blue);
347        dst->A = static_cast<unsigned char>(src->alpha);
348    }
349
350    static void average(A8R8G8B8 *dst, const A8R8G8B8 *src1, const A8R8G8B8 *src2)
351    {
352        *(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2);
353    }
354};
355
356struct R8G8B8A8
357{
358    unsigned char R;
359    unsigned char G;
360    unsigned char B;
361    unsigned char A;
362
363    static void readColor(gl::ColorF *dst, const R8G8B8A8 *src)
364    {
365        dst->red   = gl::normalizedToFloat(src->R);
366        dst->green = gl::normalizedToFloat(src->G);
367        dst->blue  = gl::normalizedToFloat(src->B);
368        dst->alpha = gl::normalizedToFloat(src->A);
369    }
370
371    static void readColor(gl::ColorUI *dst, const R8G8B8A8 *src)
372    {
373        dst->red   = src->R;
374        dst->green = src->G;
375        dst->blue  = src->B;
376        dst->alpha = src->A;
377    }
378
379    static void writeColor(R8G8B8A8 *dst, const gl::ColorF *src)
380    {
381        dst->R = gl::floatToNormalized<unsigned char>(src->red);
382        dst->G = gl::floatToNormalized<unsigned char>(src->green);
383        dst->B = gl::floatToNormalized<unsigned char>(src->blue);
384        dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
385    }
386
387    static void writeColor(R8G8B8A8 *dst, const gl::ColorUI *src)
388    {
389        dst->R = static_cast<unsigned char>(src->red);
390        dst->G = static_cast<unsigned char>(src->green);
391        dst->B = static_cast<unsigned char>(src->blue);
392        dst->A = static_cast<unsigned char>(src->alpha);
393    }
394
395    static void average(R8G8B8A8 *dst, const R8G8B8A8 *src1, const R8G8B8A8 *src2)
396    {
397        *(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2);
398    }
399};
400
401struct B8G8R8A8
402{
403    unsigned char B;
404    unsigned char G;
405    unsigned char R;
406    unsigned char A;
407
408    static void readColor(gl::ColorF *dst, const B8G8R8A8 *src)
409    {
410        dst->red   = gl::normalizedToFloat(src->R);
411        dst->green = gl::normalizedToFloat(src->G);
412        dst->blue  = gl::normalizedToFloat(src->B);
413        dst->alpha = gl::normalizedToFloat(src->A);
414    }
415
416    static void readColor(gl::ColorUI *dst, const B8G8R8A8 *src)
417    {
418        dst->red   = src->R;
419        dst->green = src->G;
420        dst->blue  = src->B;
421        dst->alpha = src->A;
422    }
423
424    static void writeColor(B8G8R8A8 *dst, const gl::ColorF *src)
425    {
426        dst->R = gl::floatToNormalized<unsigned char>(src->red);
427        dst->G = gl::floatToNormalized<unsigned char>(src->green);
428        dst->B = gl::floatToNormalized<unsigned char>(src->blue);
429        dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
430    }
431
432    static void writeColor(B8G8R8A8 *dst, const gl::ColorUI *src)
433    {
434        dst->R = static_cast<unsigned char>(src->red);
435        dst->G = static_cast<unsigned char>(src->green);
436        dst->B = static_cast<unsigned char>(src->blue);
437        dst->A = static_cast<unsigned char>(src->alpha);
438    }
439
440    static void average(B8G8R8A8 *dst, const B8G8R8A8 *src1, const B8G8R8A8 *src2)
441    {
442        *(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2);
443    }
444};
445
446struct B8G8R8X8
447{
448    unsigned char B;
449    unsigned char G;
450    unsigned char R;
451    unsigned char X;
452
453    static void readColor(gl::ColorF *dst, const B8G8R8X8 *src)
454    {
455        dst->red = gl::normalizedToFloat(src->R);
456        dst->green = gl::normalizedToFloat(src->G);
457        dst->blue = gl::normalizedToFloat(src->B);
458        dst->alpha = 1.0f;
459    }
460
461    static void readColor(gl::ColorUI *dst, const B8G8R8X8 *src)
462    {
463        dst->red = src->R;
464        dst->green = src->G;
465        dst->blue = src->B;
466        dst->alpha = 1;
467    }
468
469    static void writeColor(B8G8R8X8 *dst, const gl::ColorF *src)
470    {
471        dst->R = gl::floatToNormalized<unsigned char>(src->red);
472        dst->G = gl::floatToNormalized<unsigned char>(src->green);
473        dst->B = gl::floatToNormalized<unsigned char>(src->blue);
474        dst->X = 255;
475    }
476
477    static void writeColor(B8G8R8X8 *dst, const gl::ColorUI *src)
478    {
479        dst->R = static_cast<unsigned char>(src->red);
480        dst->G = static_cast<unsigned char>(src->green);
481        dst->B = static_cast<unsigned char>(src->blue);
482        dst->X = 255;
483    }
484
485    static void average(B8G8R8X8 *dst, const B8G8R8X8 *src1, const B8G8R8X8 *src2)
486    {
487        *(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2);
488        dst->X = 255;
489    }
490};
491
492struct B5G5R5A1
493{
494    unsigned short BGRA;
495
496    static void readColor(gl::ColorF *dst, const B5G5R5A1 *src)
497    {
498        dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 15>(src->BGRA));
499        dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 10>(src->BGRA));
500        dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5,  5>(src->BGRA));
501        dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5,  0>(src->BGRA));
502    }
503
504    static void writeColor(B5G5R5A1 *dst, const gl::ColorF *src)
505    {
506        dst->BGRA = gl::shiftData<1, 15>(gl::floatToNormalized<1, unsigned short>(src->alpha)) |
507                    gl::shiftData<5, 10>(gl::floatToNormalized<5, unsigned short>(src->red))   |
508                    gl::shiftData<5,  5>(gl::floatToNormalized<5, unsigned short>(src->green)) |
509                    gl::shiftData<5,  0>(gl::floatToNormalized<5, unsigned short>(src->blue));
510    }
511
512    static void average(B5G5R5A1 *dst, const B5G5R5A1 *src1, const B5G5R5A1 *src2)
513    {
514        dst->BGRA = gl::shiftData<1, 15>(gl::average(gl::getShiftedData<1, 15>(src1->BGRA), gl::getShiftedData<1, 15>(src2->BGRA))) |
515                    gl::shiftData<5, 10>(gl::average(gl::getShiftedData<5, 10>(src1->BGRA), gl::getShiftedData<5, 10>(src2->BGRA))) |
516                    gl::shiftData<5,  5>(gl::average(gl::getShiftedData<5,  5>(src1->BGRA), gl::getShiftedData<5,  5>(src2->BGRA))) |
517                    gl::shiftData<5,  0>(gl::average(gl::getShiftedData<5,  0>(src1->BGRA), gl::getShiftedData<5,  0>(src2->BGRA)));
518    }
519};
520
521struct R5G5B5A1
522{
523    unsigned short RGBA;
524
525    static void readColor(gl::ColorF *dst, const R5G5B5A1 *src)
526    {
527        dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 15>(src->RGBA));
528        dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5, 10>(src->RGBA));
529        dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5,  5>(src->RGBA));
530        dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5,  0>(src->RGBA));
531    }
532
533    static void writeColor(R5G5B5A1 *dst, const gl::ColorF *src)
534    {
535        dst->RGBA = gl::shiftData<1, 15>(gl::floatToNormalized<1, unsigned short>(src->alpha)) |
536                    gl::shiftData<5, 10>(gl::floatToNormalized<5, unsigned short>(src->blue))  |
537                    gl::shiftData<5,  5>(gl::floatToNormalized<5, unsigned short>(src->green)) |
538                    gl::shiftData<5,  0>(gl::floatToNormalized<5, unsigned short>(src->red));
539    }
540
541    static void average(R5G5B5A1 *dst, const R5G5B5A1 *src1, const R5G5B5A1 *src2)
542    {
543        dst->RGBA = gl::shiftData<1, 15>(gl::average(gl::getShiftedData<1, 15>(src1->RGBA), gl::getShiftedData<1, 15>(src2->RGBA))) |
544                    gl::shiftData<5, 10>(gl::average(gl::getShiftedData<5, 10>(src1->RGBA), gl::getShiftedData<5, 10>(src2->RGBA))) |
545                    gl::shiftData<5,  5>(gl::average(gl::getShiftedData<5,  5>(src1->RGBA), gl::getShiftedData<5,  5>(src2->RGBA))) |
546                    gl::shiftData<5,  0>(gl::average(gl::getShiftedData<5,  0>(src1->RGBA), gl::getShiftedData<5,  0>(src2->RGBA)));
547    }
548};
549
550struct R4G4B4A4
551{
552    unsigned char R : 4;
553    unsigned char G : 4;
554    unsigned char B : 4;
555    unsigned char A : 4;
556
557    static void readColor(gl::ColorF *dst, const R4G4B4A4 *src)
558    {
559        dst->red   = gl::normalizedToFloat<4>(src->R);
560        dst->green = gl::normalizedToFloat<4>(src->G);
561        dst->blue  = gl::normalizedToFloat<4>(src->B);
562        dst->alpha = gl::normalizedToFloat<4>(src->A);
563    }
564
565    static void writeColor(R4G4B4A4 *dst, const gl::ColorF *src)
566    {
567        dst->R = gl::floatToNormalized<4, unsigned char>(src->red);
568        dst->G = gl::floatToNormalized<4, unsigned char>(src->green);
569        dst->B = gl::floatToNormalized<4, unsigned char>(src->blue);
570        dst->A = gl::floatToNormalized<4, unsigned char>(src->alpha);
571    }
572
573    static void average(R4G4B4A4 *dst, const R4G4B4A4 *src1, const R4G4B4A4 *src2)
574    {
575        dst->R = gl::average(src1->R, src2->R);
576        dst->G = gl::average(src1->G, src2->G);
577        dst->B = gl::average(src1->B, src2->B);
578        dst->A = gl::average(src1->A, src2->A);
579    }
580};
581
582struct A4R4G4B4
583{
584    unsigned char A : 4;
585    unsigned char R : 4;
586    unsigned char G : 4;
587    unsigned char B : 4;
588
589    static void readColor(gl::ColorF *dst, const A4R4G4B4 *src)
590    {
591        dst->red   = gl::normalizedToFloat<4>(src->R);
592        dst->green = gl::normalizedToFloat<4>(src->G);
593        dst->blue  = gl::normalizedToFloat<4>(src->B);
594        dst->alpha = gl::normalizedToFloat<4>(src->A);
595    }
596
597    static void writeColor(A4R4G4B4 *dst, const gl::ColorF *src)
598    {
599        dst->R = gl::floatToNormalized<4, unsigned char>(src->red);
600        dst->G = gl::floatToNormalized<4, unsigned char>(src->green);
601        dst->B = gl::floatToNormalized<4, unsigned char>(src->blue);
602        dst->A = gl::floatToNormalized<4, unsigned char>(src->alpha);
603    }
604
605    static void average(A4R4G4B4 *dst, const A4R4G4B4 *src1, const A4R4G4B4 *src2)
606    {
607        dst->R = gl::average(src1->R, src2->R);
608        dst->G = gl::average(src1->G, src2->G);
609        dst->B = gl::average(src1->B, src2->B);
610        dst->A = gl::average(src1->A, src2->A);
611    }
612};
613
614struct B4G4R4A4
615{
616    unsigned char B : 4;
617    unsigned char G : 4;
618    unsigned char R : 4;
619    unsigned char A : 4;
620
621    static void readColor(gl::ColorF *dst, const B4G4R4A4 *src)
622    {
623        dst->red   = gl::normalizedToFloat<4>(src->R);
624        dst->green = gl::normalizedToFloat<4>(src->G);
625        dst->blue  = gl::normalizedToFloat<4>(src->B);
626        dst->alpha = gl::normalizedToFloat<4>(src->A);
627    }
628
629    static void writeColor(B4G4R4A4 *dst, const gl::ColorF *src)
630    {
631        dst->R = gl::floatToNormalized<4, unsigned char>(src->red);
632        dst->G = gl::floatToNormalized<4, unsigned char>(src->green);
633        dst->B = gl::floatToNormalized<4, unsigned char>(src->blue);
634        dst->A = gl::floatToNormalized<4, unsigned char>(src->alpha);
635    }
636
637    static void average(B4G4R4A4 *dst, const B4G4R4A4 *src1, const B4G4R4A4 *src2)
638    {
639        dst->R = gl::average(src1->R, src2->R);
640        dst->G = gl::average(src1->G, src2->G);
641        dst->B = gl::average(src1->B, src2->B);
642        dst->A = gl::average(src1->A, src2->A);
643    }
644};
645
646struct R16
647{
648    unsigned short R;
649
650    static void readColor(gl::ColorF *dst, const R16 *src)
651    {
652        dst->red   = gl::normalizedToFloat(src->R);
653        dst->green = 0.0f;
654        dst->blue  = 0.0f;
655        dst->alpha = 1.0f;
656    }
657
658    static void readColor(gl::ColorUI *dst, const R16 *src)
659    {
660        dst->red   = src->R;
661        dst->green = 0;
662        dst->blue  = 0;
663        dst->alpha = 1;
664    }
665
666    static void writeColor(R16 *dst, const gl::ColorF *src)
667    {
668        dst->R = gl::floatToNormalized<unsigned short>(src->red);
669    }
670
671    static void writeColor(R16 *dst, const gl::ColorUI *src)
672    {
673        dst->R = static_cast<unsigned short>(src->red);
674    }
675
676    static void average(R16 *dst, const R16 *src1, const R16 *src2)
677    {
678        dst->R = gl::average(src1->R, src2->R);
679    }
680};
681
682struct R16G16
683{
684    unsigned short R;
685    unsigned short G;
686
687    static void readColor(gl::ColorF *dst, const R16G16 *src)
688    {
689        dst->red   = gl::normalizedToFloat(src->R);
690        dst->green = gl::normalizedToFloat(src->G);
691        dst->blue  = 0.0f;
692        dst->alpha = 1.0f;
693    }
694
695    static void readColor(gl::ColorUI *dst, const R16G16 *src)
696    {
697        dst->red = src->R;
698        dst->green = src->G;
699        dst->blue  = 0;
700        dst->alpha = 1;
701    }
702
703    static void writeColor(R16G16 *dst, const gl::ColorF *src)
704    {
705        dst->R = gl::floatToNormalized<unsigned short>(src->red);
706        dst->G = gl::floatToNormalized<unsigned short>(src->green);
707    }
708
709    static void writeColor(R16G16 *dst, const gl::ColorUI *src)
710    {
711        dst->R = static_cast<unsigned short>(src->red);
712        dst->G = static_cast<unsigned short>(src->green);
713    }
714
715    static void average(R16G16 *dst, const R16G16 *src1, const R16G16 *src2)
716    {
717        dst->R = gl::average(src1->R, src2->R);
718        dst->G = gl::average(src1->G, src2->G);
719    }
720};
721
722struct R16G16B16
723{
724    unsigned short R;
725    unsigned short G;
726    unsigned short B;
727
728    static void readColor(gl::ColorF *dst, const R16G16B16 *src)
729    {
730        dst->red   = gl::normalizedToFloat(src->R);
731        dst->green = gl::normalizedToFloat(src->G);
732        dst->blue  = gl::normalizedToFloat(src->B);
733        dst->alpha = 1.0f;
734    }
735
736    static void readColor(gl::ColorUI *dst, const R16G16B16 *src)
737    {
738        dst->red   = src->R;
739        dst->green = src->G;
740        dst->blue  = src->B;
741        dst->alpha = 1;
742    }
743
744    static void writeColor(R16G16B16 *dst, const gl::ColorF *src)
745    {
746        dst->R = gl::floatToNormalized<unsigned short>(src->red);
747        dst->G = gl::floatToNormalized<unsigned short>(src->green);
748        dst->B = gl::floatToNormalized<unsigned short>(src->blue);
749    }
750
751    static void writeColor(R16G16B16 *dst, const gl::ColorUI *src)
752    {
753        dst->R = static_cast<unsigned short>(src->red);
754        dst->G = static_cast<unsigned short>(src->green);
755        dst->B = static_cast<unsigned short>(src->blue);
756    }
757
758    static void average(R16G16B16 *dst, const R16G16B16 *src1, const R16G16B16 *src2)
759    {
760        dst->R = gl::average(src1->R, src2->R);
761        dst->G = gl::average(src1->G, src2->G);
762        dst->B = gl::average(src1->B, src2->B);
763    }
764};
765
766struct R16G16B16A16
767{
768    unsigned short R;
769    unsigned short G;
770    unsigned short B;
771    unsigned short A;
772
773    static void readColor(gl::ColorF *dst, const R16G16B16A16 *src)
774    {
775        dst->red   = gl::normalizedToFloat(src->R);
776        dst->green = gl::normalizedToFloat(src->G);
777        dst->blue  = gl::normalizedToFloat(src->B);
778        dst->alpha = gl::normalizedToFloat(src->A);
779    }
780
781    static void readColor(gl::ColorUI *dst, const R16G16B16A16 *src)
782    {
783        dst->red   = src->R;
784        dst->green = src->G;
785        dst->blue  = src->B;
786        dst->alpha = src->A;
787    }
788
789    static void writeColor(R16G16B16A16 *dst, const gl::ColorF *src)
790    {
791        dst->R = gl::floatToNormalized<unsigned short>(src->red);
792        dst->G = gl::floatToNormalized<unsigned short>(src->green);
793        dst->B = gl::floatToNormalized<unsigned short>(src->blue);
794        dst->A = gl::floatToNormalized<unsigned short>(src->alpha);
795    }
796
797    static void writeColor(R16G16B16A16 *dst, const gl::ColorUI *src)
798    {
799        dst->R = static_cast<unsigned short>(src->red);
800        dst->G = static_cast<unsigned short>(src->green);
801        dst->B = static_cast<unsigned short>(src->blue);
802        dst->A = static_cast<unsigned short>(src->alpha);
803    }
804
805    static void average(R16G16B16A16 *dst, const R16G16B16A16 *src1, const R16G16B16A16 *src2)
806    {
807        dst->R = gl::average(src1->R, src2->R);
808        dst->G = gl::average(src1->G, src2->G);
809        dst->B = gl::average(src1->B, src2->B);
810        dst->A = gl::average(src1->A, src2->A);
811    }
812};
813
814struct R32
815{
816    unsigned int R;
817
818    static void readColor(gl::ColorF *dst, const R32 *src)
819    {
820        dst->red   = gl::normalizedToFloat(src->R);
821        dst->green = 0.0f;
822        dst->blue  = 0.0f;
823        dst->alpha = 1.0f;
824    }
825
826    static void readColor(gl::ColorUI *dst, const R32 *src)
827    {
828        dst->red   = src->R;
829        dst->green = 0;
830        dst->blue  = 0;
831        dst->alpha = 1;
832    }
833
834    static void writeColor(R32 *dst, const gl::ColorF *src)
835    {
836        dst->R = gl::floatToNormalized<unsigned int>(src->red);
837    }
838
839    static void writeColor(R32 *dst, const gl::ColorUI *src)
840    {
841        dst->R = static_cast<unsigned int>(src->red);
842    }
843
844    static void average(R32 *dst, const R32 *src1, const R32 *src2)
845    {
846        dst->R = gl::average(src1->R, src2->R);
847    }
848};
849
850struct R32G32
851{
852    unsigned int R;
853    unsigned int G;
854
855    static void readColor(gl::ColorF *dst, const R32G32 *src)
856    {
857        dst->red   = gl::normalizedToFloat(src->R);
858        dst->green = gl::normalizedToFloat(src->G);
859        dst->blue  = 0.0f;
860        dst->alpha = 1.0f;
861    }
862
863    static void readColor(gl::ColorUI *dst, const R32G32 *src)
864    {
865        dst->red   = src->R;
866        dst->green = src->G;
867        dst->blue  = 0;
868        dst->alpha = 1;
869    }
870
871    static void writeColor(R32G32 *dst, const gl::ColorF *src)
872    {
873        dst->R = gl::floatToNormalized<unsigned int>(src->red);
874        dst->G = gl::floatToNormalized<unsigned int>(src->green);
875    }
876
877    static void writeColor(R32G32 *dst, const gl::ColorUI *src)
878    {
879        dst->R = static_cast<unsigned int>(src->red);
880        dst->G = static_cast<unsigned int>(src->green);
881    }
882
883    static void average(R32G32 *dst, const R32G32 *src1, const R32G32 *src2)
884    {
885        dst->R = gl::average(src1->R, src2->R);
886        dst->G = gl::average(src1->G, src2->G);
887    }
888};
889
890struct R32G32B32
891{
892    unsigned int R;
893    unsigned int G;
894    unsigned int B;
895
896    static void readColor(gl::ColorF *dst, const R32G32B32 *src)
897    {
898        dst->red   = gl::normalizedToFloat(src->R);
899        dst->green = gl::normalizedToFloat(src->G);
900        dst->blue  = gl::normalizedToFloat(src->B);
901        dst->alpha = 1.0f;
902    }
903
904    static void readColor(gl::ColorUI *dst, const R32G32B32 *src)
905    {
906        dst->red   = src->R;
907        dst->green = src->G;
908        dst->blue  = src->B;
909        dst->alpha = 1;
910    }
911
912    static void writeColor(R32G32B32 *dst, const gl::ColorF *src)
913    {
914        dst->R = gl::floatToNormalized<unsigned int>(src->red);
915        dst->G = gl::floatToNormalized<unsigned int>(src->green);
916        dst->B = gl::floatToNormalized<unsigned int>(src->blue);
917    }
918
919    static void writeColor(R32G32B32 *dst, const gl::ColorUI *src)
920    {
921        dst->R = static_cast<unsigned int>(src->red);
922        dst->G = static_cast<unsigned int>(src->green);
923        dst->B = static_cast<unsigned int>(src->blue);
924    }
925
926    static void average(R32G32B32 *dst, const R32G32B32 *src1, const R32G32B32 *src2)
927    {
928        dst->R = gl::average(src1->R, src2->R);
929        dst->G = gl::average(src1->G, src2->G);
930        dst->B = gl::average(src1->B, src2->B);
931    }
932};
933
934struct R32G32B32A32
935{
936    unsigned int R;
937    unsigned int G;
938    unsigned int B;
939    unsigned int A;
940
941    static void readColor(gl::ColorF *dst, const R32G32B32A32 *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 = gl::normalizedToFloat(src->A);
947    }
948
949    static void readColor(gl::ColorUI *dst, const R32G32B32A32 *src)
950    {
951        dst->red   = src->R;
952        dst->green = src->G;
953        dst->blue  = src->B;
954        dst->alpha = src->A;
955    }
956
957    static void writeColor(R32G32B32A32 *dst, const gl::ColorF *src)
958    {
959        dst->R = gl::floatToNormalized<unsigned int>(src->red);
960        dst->G = gl::floatToNormalized<unsigned int>(src->green);
961        dst->B = gl::floatToNormalized<unsigned int>(src->blue);
962        dst->A = gl::floatToNormalized<unsigned int>(src->alpha);
963    }
964
965    static void writeColor(R32G32B32A32 *dst, const gl::ColorUI *src)
966    {
967        dst->R = static_cast<unsigned int>(src->red);
968        dst->G = static_cast<unsigned int>(src->green);
969        dst->B = static_cast<unsigned int>(src->blue);
970        dst->A = static_cast<unsigned int>(src->alpha);
971    }
972
973    static void average(R32G32B32A32 *dst, const R32G32B32A32 *src1, const R32G32B32A32 *src2)
974    {
975        dst->R = gl::average(src1->R, src2->R);
976        dst->G = gl::average(src1->G, src2->G);
977        dst->B = gl::average(src1->B, src2->B);
978        dst->A = gl::average(src1->A, src2->A);
979    }
980};
981
982struct R8S
983{
984    char R;
985
986    static void readColor(gl::ColorF *dst, const R8S *src)
987    {
988        dst->red   = gl::normalizedToFloat(src->R);
989        dst->green = 0.0f;
990        dst->blue  = 0.0f;
991        dst->alpha = 1.0f;
992    }
993
994    static void readColor(gl::ColorI *dst, const R8S *src)
995    {
996        dst->red   = src->R;
997        dst->green = 0;
998        dst->blue  = 0;
999        dst->alpha = 1;
1000    }
1001
1002    static void writeColor(R8S *dst, const gl::ColorF *src)
1003    {
1004        dst->R = gl::floatToNormalized<char>(src->red);
1005    }
1006
1007    static void writeColor(R8S *dst, const gl::ColorI *src)
1008    {
1009        dst->R = static_cast<char>(src->red);
1010    }
1011
1012    static void average(R8S *dst, const R8S *src1, const R8S *src2)
1013    {
1014        dst->R = gl::average(src1->R, src2->R);
1015    }
1016};
1017
1018struct R8G8S
1019{
1020    char R;
1021    char G;
1022
1023    static void readColor(gl::ColorF *dst, const R8G8S *src)
1024    {
1025        dst->red   = gl::normalizedToFloat(src->R);
1026        dst->green = gl::normalizedToFloat(src->G);
1027        dst->blue  = 0.0f;
1028        dst->alpha = 1.0f;
1029    }
1030
1031    static void readColor(gl::ColorI *dst, const R8G8S *src)
1032    {
1033        dst->red   = src->R;
1034        dst->green = src->G;
1035        dst->blue  = 0;
1036        dst->alpha = 1;
1037    }
1038
1039    static void writeColor(R8G8S *dst, const gl::ColorF *src)
1040    {
1041        dst->R = gl::floatToNormalized<char>(src->red);
1042        dst->G = gl::floatToNormalized<char>(src->green);
1043    }
1044
1045    static void writeColor(R8G8S *dst, const gl::ColorI *src)
1046    {
1047        dst->R = static_cast<char>(src->red);
1048        dst->G = static_cast<char>(src->green);
1049    }
1050
1051    static void average(R8G8S *dst, const R8G8S *src1, const R8G8S *src2)
1052    {
1053        dst->R = gl::average(src1->R, src2->R);
1054        dst->G = gl::average(src1->G, src2->G);
1055    }
1056};
1057
1058struct R8G8B8S
1059{
1060    char R;
1061    char G;
1062    char B;
1063
1064    static void readColor(gl::ColorF *dst, const R8G8B8S *src)
1065    {
1066        dst->red   = gl::normalizedToFloat(src->R);
1067        dst->green = gl::normalizedToFloat(src->G);
1068        dst->blue  = gl::normalizedToFloat(src->B);
1069        dst->alpha = 1.0f;
1070    }
1071
1072    static void readColor(gl::ColorI *dst, const R8G8B8S *src)
1073    {
1074        dst->red   = src->R;
1075        dst->green = src->G;
1076        dst->blue  = src->B;
1077        dst->alpha = 1;
1078    }
1079
1080    static void writeColor(R8G8B8S *dst, const gl::ColorF *src)
1081    {
1082        dst->R = gl::floatToNormalized<char>(src->red);
1083        dst->G = gl::floatToNormalized<char>(src->green);
1084        dst->B = gl::floatToNormalized<char>(src->blue);
1085    }
1086
1087    static void writeColor(R8G8B8S *dst, const gl::ColorI *src)
1088    {
1089        dst->R = static_cast<char>(src->red);
1090        dst->G = static_cast<char>(src->green);
1091        dst->B = static_cast<char>(src->blue);
1092    }
1093
1094    static void average(R8G8B8S *dst, const R8G8B8S *src1, const R8G8B8S *src2)
1095    {
1096        dst->R = gl::average(src1->R, src2->R);
1097        dst->G = gl::average(src1->G, src2->G);
1098        dst->B = gl::average(src1->B, src2->B);
1099    }
1100};
1101
1102struct R8G8B8A8S
1103{
1104    char R;
1105    char G;
1106    char B;
1107    char A;
1108
1109    static void readColor(gl::ColorF *dst, const R8G8B8A8S *src)
1110    {
1111        dst->red   = gl::normalizedToFloat(src->R);
1112        dst->green = gl::normalizedToFloat(src->G);
1113        dst->blue  = gl::normalizedToFloat(src->B);
1114        dst->alpha = gl::normalizedToFloat(src->A);
1115    }
1116
1117    static void readColor(gl::ColorI *dst, const R8G8B8A8S *src)
1118    {
1119        dst->red   = src->R;
1120        dst->green = src->G;
1121        dst->blue  = src->B;
1122        dst->alpha = src->A;
1123    }
1124
1125    static void writeColor(R8G8B8A8S *dst, const gl::ColorF *src)
1126    {
1127        dst->R = gl::floatToNormalized<char>(src->red);
1128        dst->G = gl::floatToNormalized<char>(src->green);
1129        dst->B = gl::floatToNormalized<char>(src->blue);
1130        dst->A = gl::floatToNormalized<char>(src->alpha);
1131    }
1132
1133    static void writeColor(R8G8B8A8S *dst, const gl::ColorI *src)
1134    {
1135        dst->R = static_cast<char>(src->red);
1136        dst->G = static_cast<char>(src->green);
1137        dst->B = static_cast<char>(src->blue);
1138        dst->A = static_cast<char>(src->alpha);
1139    }
1140
1141    static void average(R8G8B8A8S *dst, const R8G8B8A8S *src1, const R8G8B8A8S *src2)
1142    {
1143        dst->R = gl::average(src1->R, src2->R);
1144        dst->G = gl::average(src1->G, src2->G);
1145        dst->B = gl::average(src1->B, src2->B);
1146        dst->A = gl::average(src1->A, src2->A);
1147    }
1148};
1149
1150struct R16S
1151{
1152    short R;
1153
1154    static void readColor(gl::ColorF *dst, const R16S *src)
1155    {
1156        dst->red   = gl::normalizedToFloat(src->R);
1157        dst->green = 0.0f;
1158        dst->blue  = 0.0f;
1159        dst->alpha = 1.0f;
1160    }
1161
1162    static void readColor(gl::ColorI *dst, const R16S *src)
1163    {
1164        dst->red   = src->R;
1165        dst->green = 0;
1166        dst->blue  = 0;
1167        dst->alpha = 1;
1168    }
1169
1170    static void writeColor(R16S *dst, const gl::ColorF *src)
1171    {
1172        dst->R = gl::floatToNormalized<short>(src->red);
1173    }
1174
1175    static void writeColor(R16S *dst, const gl::ColorI *src)
1176    {
1177        dst->R = static_cast<short>(src->red);
1178    }
1179
1180    static void average(R16S *dst, const R16S *src1, const R16S *src2)
1181    {
1182        dst->R = gl::average(src1->R, src2->R);
1183    }
1184};
1185
1186struct R16G16S
1187{
1188    short R;
1189    short G;
1190
1191    static void readColor(gl::ColorF *dst, const R16G16S *src)
1192    {
1193        dst->red   = gl::normalizedToFloat(src->R);
1194        dst->green = gl::normalizedToFloat(src->G);
1195        dst->blue  = 0.0f;
1196        dst->alpha = 1.0f;
1197    }
1198
1199    static void readColor(gl::ColorI *dst, const R16G16S *src)
1200    {
1201        dst->red   = src->R;
1202        dst->green = src->G;
1203        dst->blue  = 0;
1204        dst->alpha = 1;
1205    }
1206
1207    static void writeColor(R16G16S *dst, const gl::ColorF *src)
1208    {
1209        dst->R = gl::floatToNormalized<short>(src->red);
1210        dst->G = gl::floatToNormalized<short>(src->green);
1211    }
1212
1213    static void writeColor(R16G16S *dst, const gl::ColorI *src)
1214    {
1215        dst->R = static_cast<short>(src->red);
1216        dst->G = static_cast<short>(src->green);
1217    }
1218
1219    static void average(R16G16S *dst, const R16G16S *src1, const R16G16S *src2)
1220    {
1221        dst->R = gl::average(src1->R, src2->R);
1222        dst->G = gl::average(src1->G, src2->G);
1223    }
1224};
1225
1226struct R16G16B16S
1227{
1228    short R;
1229    short G;
1230    short B;
1231
1232    static void readColor(gl::ColorF *dst, const R16G16B16S *src)
1233    {
1234        dst->red   = gl::normalizedToFloat(src->R);
1235        dst->green = gl::normalizedToFloat(src->G);
1236        dst->blue  = gl::normalizedToFloat(src->B);
1237        dst->alpha = 1.0f;
1238    }
1239
1240    static void readColor(gl::ColorI *dst, const R16G16B16S *src)
1241    {
1242        dst->red   = src->R;
1243        dst->green = src->G;
1244        dst->blue  = src->B;
1245        dst->alpha = 1;
1246    }
1247
1248    static void writeColor(R16G16B16S *dst, const gl::ColorF *src)
1249    {
1250        dst->R = gl::floatToNormalized<short>(src->red);
1251        dst->G = gl::floatToNormalized<short>(src->green);
1252        dst->B = gl::floatToNormalized<short>(src->blue);
1253    }
1254
1255    static void writeColor(R16G16B16S *dst, const gl::ColorI *src)
1256    {
1257        dst->R = static_cast<short>(src->red);
1258        dst->G = static_cast<short>(src->green);
1259        dst->B = static_cast<short>(src->blue);
1260    }
1261
1262    static void average(R16G16B16S *dst, const R16G16B16S *src1, const R16G16B16S *src2)
1263    {
1264        dst->R = gl::average(src1->R, src2->R);
1265        dst->G = gl::average(src1->G, src2->G);
1266        dst->B = gl::average(src1->B, src2->B);
1267    }
1268};
1269
1270struct R16G16B16A16S
1271{
1272    short R;
1273    short G;
1274    short B;
1275    short A;
1276
1277    static void readColor(gl::ColorF *dst, const R16G16B16A16S *src)
1278    {
1279        dst->red   = gl::normalizedToFloat(src->R);
1280        dst->green = gl::normalizedToFloat(src->G);
1281        dst->blue  = gl::normalizedToFloat(src->B);
1282        dst->alpha = gl::normalizedToFloat(src->A);
1283    }
1284
1285    static void readColor(gl::ColorI *dst, const R16G16B16A16S *src)
1286    {
1287        dst->red   = src->R;
1288        dst->green = src->G;
1289        dst->blue  = src->B;
1290        dst->alpha = src->A;
1291    }
1292
1293    static void writeColor(R16G16B16A16S *dst, const gl::ColorF *src)
1294    {
1295        dst->R = gl::floatToNormalized<short>(src->red);
1296        dst->G = gl::floatToNormalized<short>(src->green);
1297        dst->B = gl::floatToNormalized<short>(src->blue);
1298        dst->A = gl::floatToNormalized<short>(src->alpha);
1299    }
1300
1301    static void writeColor(R16G16B16A16S *dst, const gl::ColorI *src)
1302    {
1303        dst->R = static_cast<short>(src->red);
1304        dst->G = static_cast<short>(src->green);
1305        dst->B = static_cast<short>(src->blue);
1306        dst->A = static_cast<short>(src->alpha);
1307    }
1308
1309    static void average(R16G16B16A16S *dst, const R16G16B16A16S *src1, const R16G16B16A16S *src2)
1310    {
1311        dst->R = gl::average(src1->R, src2->R);
1312        dst->G = gl::average(src1->G, src2->G);
1313        dst->B = gl::average(src1->B, src2->B);
1314        dst->A = gl::average(src1->A, src2->A);
1315    }
1316};
1317
1318struct R32S
1319{
1320    int R;
1321
1322    static void readColor(gl::ColorF *dst, const R32S *src)
1323    {
1324        dst->red   = gl::normalizedToFloat(src->R);
1325        dst->green = 0.0f;
1326        dst->blue  = 0.0f;
1327        dst->alpha = 1.0f;
1328    }
1329
1330    static void readColor(gl::ColorI *dst, const R32S *src)
1331    {
1332        dst->red   = src->R;
1333        dst->green = 0;
1334        dst->blue  = 0;
1335        dst->alpha = 1;
1336    }
1337
1338    static void writeColor(R32S *dst, const gl::ColorF *src)
1339    {
1340        dst->R = gl::floatToNormalized<int>(src->red);
1341    }
1342
1343    static void writeColor(R32S *dst, const gl::ColorI *src)
1344    {
1345        dst->R = static_cast<int>(src->red);
1346    }
1347
1348    static void average(R32S *dst, const R32S *src1, const R32S *src2)
1349    {
1350        dst->R = gl::average(src1->R, src2->R);
1351    }
1352};
1353
1354struct R32G32S
1355{
1356    int R;
1357    int G;
1358
1359    static void readColor(gl::ColorF *dst, const R32G32S *src)
1360    {
1361        dst->red   = gl::normalizedToFloat(src->R);
1362        dst->green = gl::normalizedToFloat(src->G);
1363        dst->blue  = 0.0f;
1364        dst->alpha = 1.0f;
1365    }
1366
1367    static void readColor(gl::ColorI *dst, const R32G32S *src)
1368    {
1369        dst->red   = src->R;
1370        dst->green = src->G;
1371        dst->blue  = 0;
1372        dst->alpha = 1;
1373    }
1374
1375    static void writeColor(R32G32S *dst, const gl::ColorF *src)
1376    {
1377        dst->R = gl::floatToNormalized<int>(src->red);
1378        dst->G = gl::floatToNormalized<int>(src->green);
1379    }
1380
1381    static void writeColor(R32G32S *dst, const gl::ColorI *src)
1382    {
1383        dst->R = static_cast<int>(src->red);
1384        dst->G = static_cast<int>(src->green);
1385    }
1386
1387    static void average(R32G32S *dst, const R32G32S *src1, const R32G32S *src2)
1388    {
1389        dst->R = gl::average(src1->R, src2->R);
1390        dst->G = gl::average(src1->G, src2->G);
1391    }
1392};
1393
1394struct R32G32B32S
1395{
1396    int R;
1397    int G;
1398    int B;
1399
1400    static void readColor(gl::ColorF *dst, const R32G32B32S *src)
1401    {
1402        dst->red   = gl::normalizedToFloat(src->R);
1403        dst->green = gl::normalizedToFloat(src->G);
1404        dst->blue  = gl::normalizedToFloat(src->B);
1405        dst->alpha = 1.0f;
1406    }
1407
1408    static void readColor(gl::ColorI *dst, const R32G32B32S *src)
1409    {
1410        dst->red   = src->R;
1411        dst->green = src->G;
1412        dst->blue  = src->B;
1413        dst->alpha = 1;
1414    }
1415
1416    static void writeColor(R32G32B32S *dst, const gl::ColorF *src)
1417    {
1418        dst->R = gl::floatToNormalized<int>(src->red);
1419        dst->G = gl::floatToNormalized<int>(src->green);
1420        dst->B = gl::floatToNormalized<int>(src->blue);
1421    }
1422
1423    static void writeColor(R32G32B32S *dst, const gl::ColorI *src)
1424    {
1425        dst->R = static_cast<int>(src->red);
1426        dst->G = static_cast<int>(src->green);
1427        dst->B = static_cast<int>(src->blue);
1428    }
1429
1430    static void average(R32G32B32S *dst, const R32G32B32S *src1, const R32G32B32S *src2)
1431    {
1432        dst->R = gl::average(src1->R, src2->R);
1433        dst->G = gl::average(src1->G, src2->G);
1434        dst->B = gl::average(src1->B, src2->B);
1435    }
1436};
1437
1438struct R32G32B32A32S
1439{
1440    int R;
1441    int G;
1442    int B;
1443    int A;
1444
1445    static void readColor(gl::ColorF *dst, const R32G32B32A32S *src)
1446    {
1447        dst->red   = gl::normalizedToFloat(src->R);
1448        dst->green = gl::normalizedToFloat(src->G);
1449        dst->blue  = gl::normalizedToFloat(src->B);
1450        dst->alpha = gl::normalizedToFloat(src->A);
1451    }
1452
1453    static void readColor(gl::ColorI *dst, const R32G32B32A32S *src)
1454    {
1455        dst->red   = src->R;
1456        dst->green = src->G;
1457        dst->blue  = src->B;
1458        dst->alpha = src->A;
1459    }
1460
1461    static void writeColor(R32G32B32A32S *dst, const gl::ColorF *src)
1462    {
1463        dst->R = gl::floatToNormalized<int>(src->red);
1464        dst->G = gl::floatToNormalized<int>(src->green);
1465        dst->B = gl::floatToNormalized<int>(src->blue);
1466        dst->A = gl::floatToNormalized<int>(src->alpha);
1467    }
1468
1469    static void writeColor(R32G32B32A32S *dst, const gl::ColorI *src)
1470    {
1471        dst->R = static_cast<int>(src->red);
1472        dst->G = static_cast<int>(src->green);
1473        dst->B = static_cast<int>(src->blue);
1474        dst->A = static_cast<int>(src->alpha);
1475    }
1476
1477    static void average(R32G32B32A32S *dst, const R32G32B32A32S *src1, const R32G32B32A32S *src2)
1478    {
1479        dst->R = gl::average(src1->R, src2->R);
1480        dst->G = gl::average(src1->G, src2->G);
1481        dst->B = gl::average(src1->B, src2->B);
1482        dst->A = gl::average(src1->A, src2->A);
1483    }
1484};
1485
1486struct A16B16G16R16F
1487{
1488    unsigned short A;
1489    unsigned short R;
1490    unsigned short G;
1491    unsigned short B;
1492
1493    static void readColor(gl::ColorF *dst, const A16B16G16R16F *src)
1494    {
1495        dst->red   = gl::float16ToFloat32(src->R);
1496        dst->green = gl::float16ToFloat32(src->G);
1497        dst->blue  = gl::float16ToFloat32(src->B);
1498        dst->alpha = gl::float16ToFloat32(src->A);
1499    }
1500
1501    static void writeColor(A16B16G16R16F *dst, const gl::ColorF *src)
1502    {
1503        dst->R = gl::float32ToFloat16(src->red);
1504        dst->G = gl::float32ToFloat16(src->green);
1505        dst->B = gl::float32ToFloat16(src->blue);
1506        dst->A = gl::float32ToFloat16(src->alpha);
1507    }
1508
1509    static void average(A16B16G16R16F *dst, const A16B16G16R16F *src1, const A16B16G16R16F *src2)
1510    {
1511        dst->R = gl::averageHalfFloat(src1->R, src2->R);
1512        dst->G = gl::averageHalfFloat(src1->G, src2->G);
1513        dst->B = gl::averageHalfFloat(src1->B, src2->B);
1514        dst->A = gl::averageHalfFloat(src1->A, src2->A);
1515    }
1516};
1517
1518struct R16G16B16A16F
1519{
1520    unsigned short R;
1521    unsigned short G;
1522    unsigned short B;
1523    unsigned short A;
1524
1525    static void readColor(gl::ColorF *dst, const R16G16B16A16F *src)
1526    {
1527        dst->red   = gl::float16ToFloat32(src->R);
1528        dst->green = gl::float16ToFloat32(src->G);
1529        dst->blue  = gl::float16ToFloat32(src->B);
1530        dst->alpha = gl::float16ToFloat32(src->A);
1531    }
1532
1533    static void writeColor(R16G16B16A16F *dst, const gl::ColorF *src)
1534    {
1535        dst->R = gl::float32ToFloat16(src->red);
1536        dst->G = gl::float32ToFloat16(src->green);
1537        dst->B = gl::float32ToFloat16(src->blue);
1538        dst->A = gl::float32ToFloat16(src->alpha);
1539    }
1540
1541    static void average(R16G16B16A16F *dst, const R16G16B16A16F *src1, const R16G16B16A16F *src2)
1542    {
1543        dst->R = gl::averageHalfFloat(src1->R, src2->R);
1544        dst->G = gl::averageHalfFloat(src1->G, src2->G);
1545        dst->B = gl::averageHalfFloat(src1->B, src2->B);
1546        dst->A = gl::averageHalfFloat(src1->A, src2->A);
1547    }
1548};
1549
1550struct R16F
1551{
1552    unsigned short R;
1553
1554    static void readColor(gl::ColorF *dst, const R16F *src)
1555    {
1556        dst->red   = gl::float16ToFloat32(src->R);
1557        dst->green = 0.0f;
1558        dst->blue  = 0.0f;
1559        dst->alpha = 1.0f;
1560    }
1561
1562    static void writeColor(R16F *dst, const gl::ColorF *src)
1563    {
1564        dst->R = gl::float32ToFloat16(src->red);
1565    }
1566
1567    static void average(R16F *dst, const R16F *src1, const R16F *src2)
1568    {
1569        dst->R = gl::averageHalfFloat(src1->R, src2->R);
1570    }
1571};
1572
1573struct A16F
1574{
1575    unsigned short A;
1576
1577    static void readColor(gl::ColorF *dst, const A16F *src)
1578    {
1579        dst->red   = 0.0f;
1580        dst->green = 0.0f;
1581        dst->blue  = 0.0f;
1582        dst->alpha = gl::float16ToFloat32(src->A);
1583    }
1584
1585    static void writeColor(A16F *dst, const gl::ColorF *src)
1586    {
1587        dst->A = gl::float32ToFloat16(src->alpha);
1588    }
1589
1590    static void average(A16F *dst, const A16F *src1, const A16F *src2)
1591    {
1592        dst->A = gl::averageHalfFloat(src1->A, src2->A);
1593    }
1594};
1595
1596struct L16F
1597{
1598    unsigned short L;
1599
1600    static void readColor(gl::ColorF *dst, const L16F *src)
1601    {
1602        float lum = gl::float16ToFloat32(src->L);
1603        dst->red   = lum;
1604        dst->green = lum;
1605        dst->blue  = lum;
1606        dst->alpha = 1.0f;
1607    }
1608
1609    static void writeColor(L16F *dst, const gl::ColorF *src)
1610    {
1611        dst->L = gl::float32ToFloat16((src->red + src->green + src->blue) / 3.0f);
1612    }
1613
1614    static void average(L16F *dst, const L16F *src1, const L16F *src2)
1615    {
1616        dst->L = gl::averageHalfFloat(src1->L, src2->L);
1617    }
1618};
1619
1620struct L16A16F
1621{
1622    unsigned short L;
1623    unsigned short A;
1624
1625    static void readColor(gl::ColorF *dst, const L16A16F *src)
1626    {
1627        float lum = gl::float16ToFloat32(src->L);
1628        dst->red   = lum;
1629        dst->green = lum;
1630        dst->blue  = lum;
1631        dst->alpha = gl::float16ToFloat32(src->A);
1632    }
1633
1634    static void writeColor(L16A16F *dst, const gl::ColorF *src)
1635    {
1636        dst->L = gl::float32ToFloat16((src->red + src->green + src->blue) / 3.0f);
1637        dst->A = gl::float32ToFloat16(src->alpha);
1638    }
1639
1640    static void average(L16A16F *dst, const L16A16F *src1, const L16A16F *src2)
1641    {
1642        dst->L = gl::averageHalfFloat(src1->L, src2->L);
1643        dst->A = gl::averageHalfFloat(src1->A, src2->A);
1644    }
1645};
1646
1647struct R16G16F
1648{
1649    unsigned short R;
1650    unsigned short G;
1651
1652    static void readColor(gl::ColorF *dst, const R16G16F *src)
1653    {
1654        dst->red   = gl::float16ToFloat32(src->R);
1655        dst->green = gl::float16ToFloat32(src->G);
1656        dst->blue  = 0.0f;
1657        dst->alpha = 1.0f;
1658    }
1659
1660    static void writeColor(R16G16F *dst, const gl::ColorF *src)
1661    {
1662        dst->R = gl::float32ToFloat16(src->red);
1663        dst->G = gl::float32ToFloat16(src->green);
1664    }
1665
1666    static void average(R16G16F *dst, const R16G16F *src1, const R16G16F *src2)
1667    {
1668        dst->R = gl::averageHalfFloat(src1->R, src2->R);
1669        dst->G = gl::averageHalfFloat(src1->G, src2->G);
1670    }
1671};
1672
1673struct R16G16B16F
1674{
1675    unsigned short R;
1676    unsigned short G;
1677    unsigned short B;
1678
1679    static void readColor(gl::ColorF *dst, const R16G16B16F *src)
1680    {
1681        dst->red   = gl::float16ToFloat32(src->R);
1682        dst->green = gl::float16ToFloat32(src->G);
1683        dst->blue  = gl::float16ToFloat32(src->B);
1684        dst->alpha = 1.0f;
1685    }
1686
1687    static void writeColor(R16G16B16F *dst, const gl::ColorF *src)
1688    {
1689        dst->R = gl::float32ToFloat16(src->red);
1690        dst->G = gl::float32ToFloat16(src->green);
1691        dst->B = gl::float32ToFloat16(src->blue);
1692    }
1693
1694    static void average(R16G16B16F *dst, const R16G16B16F *src1, const R16G16B16F *src2)
1695    {
1696        dst->R = gl::averageHalfFloat(src1->R, src2->R);
1697        dst->G = gl::averageHalfFloat(src1->G, src2->G);
1698        dst->B = gl::averageHalfFloat(src1->B, src2->B);
1699    }
1700};
1701
1702struct A32B32G32R32F
1703{
1704    float A;
1705    float R;
1706    float G;
1707    float B;
1708
1709    static void readColor(gl::ColorF *dst, const A32B32G32R32F *src)
1710    {
1711        dst->red   = src->R;
1712        dst->green = src->G;
1713        dst->blue  = src->B;
1714        dst->alpha = src->A;
1715    }
1716
1717    static void writeColor(A32B32G32R32F *dst, const gl::ColorF *src)
1718    {
1719        dst->R = src->red;
1720        dst->G = src->green;
1721        dst->B = src->blue;
1722        dst->A = src->alpha;
1723    }
1724
1725    static void average(A32B32G32R32F *dst, const A32B32G32R32F *src1, const A32B32G32R32F *src2)
1726    {
1727        dst->R = gl::average(src1->R, src2->R);
1728        dst->G = gl::average(src1->G, src2->G);
1729        dst->B = gl::average(src1->B, src2->B);
1730        dst->A = gl::average(src1->A, src2->A);
1731    }
1732};
1733
1734struct R32G32B32A32F
1735{
1736    float R;
1737    float G;
1738    float B;
1739    float A;
1740
1741    static void readColor(gl::ColorF *dst, const R32G32B32A32F *src)
1742    {
1743        dst->red   = src->R;
1744        dst->green = src->G;
1745        dst->blue  = src->B;
1746        dst->alpha = src->A;
1747    }
1748
1749    static void writeColor(R32G32B32A32F *dst, const gl::ColorF *src)
1750    {
1751        dst->R = src->red;
1752        dst->G = src->green;
1753        dst->B = src->blue;
1754        dst->A = src->alpha;
1755    }
1756
1757    static void average(R32G32B32A32F *dst, const R32G32B32A32F *src1, const R32G32B32A32F *src2)
1758    {
1759        dst->R = gl::average(src1->R, src2->R);
1760        dst->G = gl::average(src1->G, src2->G);
1761        dst->B = gl::average(src1->B, src2->B);
1762        dst->A = gl::average(src1->A, src2->A);
1763    }
1764};
1765
1766struct R32F
1767{
1768    float R;
1769
1770    static void readColor(gl::ColorF *dst, const R32F *src)
1771    {
1772        dst->red   = src->R;
1773        dst->green = 0.0f;
1774        dst->blue  = 0.0f;
1775        dst->alpha = 1.0f;
1776    }
1777
1778    static void writeColor(R32F *dst, const gl::ColorF *src)
1779    {
1780        dst->R = src->red;
1781    }
1782
1783    static void average(R32F *dst, const R32F *src1, const R32F *src2)
1784    {
1785        dst->R = gl::average(src1->R, src2->R);
1786    }
1787};
1788
1789struct A32F
1790{
1791    float A;
1792
1793    static void readColor(gl::ColorF *dst, const A32F *src)
1794    {
1795        dst->red   = 0.0f;
1796        dst->green = 0.0f;
1797        dst->blue  = 0.0f;
1798        dst->alpha = src->A;
1799    }
1800
1801    static void writeColor(A32F *dst, const gl::ColorF *src)
1802    {
1803        dst->A = src->alpha;
1804    }
1805
1806    static void average(A32F *dst, const A32F *src1, const A32F *src2)
1807    {
1808        dst->A = gl::average(src1->A, src2->A);
1809    }
1810};
1811
1812struct L32F
1813{
1814    float L;
1815
1816    static void readColor(gl::ColorF *dst, const L32F *src)
1817    {
1818        dst->red   = src->L;
1819        dst->green = src->L;
1820        dst->blue  = src->L;
1821        dst->alpha = 1.0f;
1822    }
1823
1824    static void writeColor(L32F *dst, const gl::ColorF *src)
1825    {
1826        dst->L = (src->red + src->green + src->blue) / 3.0f;
1827    }
1828
1829    static void average(L32F *dst, const L32F *src1, const L32F *src2)
1830    {
1831        dst->L = gl::average(src1->L, src2->L);
1832    }
1833};
1834
1835struct L32A32F
1836{
1837    float L;
1838    float A;
1839
1840    static void readColor(gl::ColorF *dst, const L32A32F *src)
1841    {
1842        dst->red   = src->L;
1843        dst->green = src->L;
1844        dst->blue  = src->L;
1845        dst->alpha = src->A;
1846    }
1847
1848    static void writeColor(L32A32F *dst, const gl::ColorF *src)
1849    {
1850        dst->L = (src->red + src->green + src->blue) / 3.0f;
1851        dst->A = src->alpha;
1852    }
1853
1854    static void average(L32A32F *dst, const L32A32F *src1, const L32A32F *src2)
1855    {
1856        dst->L = gl::average(src1->L, src2->L);
1857        dst->A = gl::average(src1->A, src2->A);
1858    }
1859};
1860
1861struct R32G32F
1862{
1863    float R;
1864    float G;
1865
1866    static void readColor(gl::ColorF *dst, const R32G32F *src)
1867    {
1868        dst->red   = src->R;
1869        dst->green = src->G;
1870        dst->blue  = 0.0f;
1871        dst->alpha = 1.0f;
1872    }
1873
1874    static void writeColor(R32G32F *dst, const gl::ColorF *src)
1875    {
1876        dst->R = src->red;
1877        dst->G = src->green;
1878    }
1879
1880    static void average(R32G32F *dst, const R32G32F *src1, const R32G32F *src2)
1881    {
1882        dst->R = gl::average(src1->R, src2->R);
1883        dst->G = gl::average(src1->G, src2->G);
1884    }
1885};
1886
1887struct R32G32B32F
1888{
1889    float R;
1890    float G;
1891    float B;
1892
1893    static void readColor(gl::ColorF *dst, const R32G32B32F *src)
1894    {
1895        dst->red   = src->R;
1896        dst->green = src->G;
1897        dst->blue  = src->B;
1898        dst->alpha = 1.0f;
1899    }
1900
1901    static void writeColor(R32G32B32F *dst, const gl::ColorF *src)
1902    {
1903        dst->R = src->red;
1904        dst->G = src->green;
1905        dst->B = src->blue;
1906    }
1907
1908    static void average(R32G32B32F *dst, const R32G32B32F *src1, const R32G32B32F *src2)
1909    {
1910        dst->R = gl::average(src1->R, src2->R);
1911        dst->G = gl::average(src1->G, src2->G);
1912        dst->B = gl::average(src1->B, src2->B);
1913    }
1914};
1915
1916struct R10G10B10A2
1917{
1918    unsigned int R : 10;
1919    unsigned int G : 10;
1920    unsigned int B : 10;
1921    unsigned int A : 2;
1922
1923    static void readColor(gl::ColorF *dst, const R10G10B10A2 *src)
1924    {
1925        dst->red   = gl::normalizedToFloat<10>(src->R);
1926        dst->green = gl::normalizedToFloat<10>(src->G);
1927        dst->blue  = gl::normalizedToFloat<10>(src->B);
1928        dst->alpha = gl::normalizedToFloat< 2>(src->A);
1929    }
1930
1931    static void readColor(gl::ColorUI *dst, const R10G10B10A2 *src)
1932    {
1933        dst->red   = src->R;
1934        dst->green = src->G;
1935        dst->blue  = src->B;
1936        dst->alpha = src->A;
1937    }
1938
1939    static void writeColor(R10G10B10A2 *dst, const gl::ColorF *src)
1940    {
1941        dst->R = gl::floatToNormalized<10, unsigned int>(src->red);
1942        dst->G = gl::floatToNormalized<10, unsigned int>(src->green);
1943        dst->B = gl::floatToNormalized<10, unsigned int>(src->blue);
1944        dst->A = gl::floatToNormalized< 2, unsigned int>(src->alpha);
1945    }
1946
1947    static void writeColor(R10G10B10A2 *dst, const gl::ColorUI *src)
1948    {
1949        dst->R = static_cast<unsigned int>(src->red);
1950        dst->G = static_cast<unsigned int>(src->green);
1951        dst->B = static_cast<unsigned int>(src->blue);
1952        dst->A = static_cast<unsigned int>(src->alpha);
1953    }
1954
1955    static void average(R10G10B10A2 *dst, const R10G10B10A2 *src1, const R10G10B10A2 *src2)
1956    {
1957        dst->R = gl::average(src1->R, src2->R);
1958        dst->G = gl::average(src1->G, src2->G);
1959        dst->B = gl::average(src1->B, src2->B);
1960        dst->A = gl::average(src1->A, src2->A);
1961    }
1962};
1963
1964struct R9G9B9E5
1965{
1966    unsigned int R : 9;
1967    unsigned int G : 9;
1968    unsigned int B : 9;
1969    unsigned int E : 5;
1970
1971    static void readColor(gl::ColorF *dst, const R9G9B9E5 *src)
1972    {
1973        gl::convert999E5toRGBFloats(gl::bitCast<unsigned int>(*src), &dst->red, &dst->green, &dst->blue);
1974        dst->alpha = 1.0f;
1975    }
1976
1977    static void writeColor(R9G9B9E5 *dst, const gl::ColorF *src)
1978    {
1979        *reinterpret_cast<unsigned int*>(dst) = gl::convertRGBFloatsTo999E5(src->red,
1980                                                                            src->green,
1981                                                                            src->blue);
1982    }
1983
1984    static void average(R9G9B9E5 *dst, const R9G9B9E5 *src1, const R9G9B9E5 *src2)
1985    {
1986        float r1, g1, b1;
1987        gl::convert999E5toRGBFloats(*reinterpret_cast<const unsigned int*>(src1), &r1, &g1, &b1);
1988
1989        float r2, g2, b2;
1990        gl::convert999E5toRGBFloats(*reinterpret_cast<const unsigned int*>(src2), &r2, &g2, &b2);
1991
1992        *reinterpret_cast<unsigned int*>(dst) = gl::convertRGBFloatsTo999E5(gl::average(r1, r2),
1993                                                                            gl::average(g1, g2),
1994                                                                            gl::average(b1, b2));
1995    }
1996};
1997
1998struct R11G11B10F
1999{
2000    unsigned int R : 11;
2001    unsigned int G : 11;
2002    unsigned int B : 10;
2003
2004    static void readColor(gl::ColorF *dst, const R11G11B10F *src)
2005    {
2006        dst->red   = gl::float11ToFloat32(src->R);
2007        dst->green = gl::float11ToFloat32(src->G);
2008        dst->blue  = gl::float10ToFloat32(src->B);
2009        dst->alpha = 1.0f;
2010    }
2011
2012    static void writeColor(R11G11B10F *dst, const gl::ColorF *src)
2013    {
2014        dst->R = gl::float32ToFloat11(src->red);
2015        dst->G = gl::float32ToFloat11(src->green);
2016        dst->B = gl::float32ToFloat10(src->blue);
2017    }
2018
2019    static void average(R11G11B10F *dst, const R11G11B10F *src1, const R11G11B10F *src2)
2020    {
2021        dst->R = gl::averageFloat11(src1->R, src2->R);
2022        dst->G = gl::averageFloat11(src1->G, src2->G);
2023        dst->B = gl::averageFloat10(src1->B, src2->B);
2024    }
2025};
2026
2027}
2028
2029#endif // LIBGLESV2_RENDERER_IMAGEFORMATS_H_
2030