1 //
2 // Copyright (c) 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
readColor(gl::ColorF * dst,const L8 * src)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
writeColor(L8 * dst,const gl::ColorF * src)26 void L8::writeColor(L8 *dst, const gl::ColorF *src)
27 {
28 dst->L = gl::floatToNormalized<uint8_t>(src->red);
29 }
30
average(L8 * dst,const L8 * src1,const L8 * src2)31 void L8::average(L8 *dst, const L8 *src1, const L8 *src2)
32 {
33 dst->L = gl::average(src1->L, src2->L);
34 }
35
readColor(gl::ColorUI * dst,const R8 * src)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
readColor(gl::ColorF * dst,const R8 * src)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
writeColor(R8 * dst,const gl::ColorUI * src)52 void R8::writeColor(R8 *dst, const gl::ColorUI *src)
53 {
54 dst->R = static_cast<uint8_t>(src->red);
55 }
56
writeColor(R8 * dst,const gl::ColorF * src)57 void R8::writeColor(R8 *dst, const gl::ColorF *src)
58 {
59 dst->R = gl::floatToNormalized<uint8_t>(src->red);
60 }
61
average(R8 * dst,const R8 * src1,const R8 * src2)62 void R8::average(R8 *dst, const R8 *src1, const R8 *src2)
63 {
64 dst->R = gl::average(src1->R, src2->R);
65 }
66
readColor(gl::ColorF * dst,const A8 * src)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
writeColor(A8 * dst,const gl::ColorF * src)75 void A8::writeColor(A8 *dst, const gl::ColorF *src)
76 {
77 dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
78 }
79
average(A8 * dst,const A8 * src1,const A8 * src2)80 void A8::average(A8 *dst, const A8 *src1, const A8 *src2)
81 {
82 dst->A = gl::average(src1->A, src2->A);
83 }
84
readColor(gl::ColorF * dst,const L8A8 * src)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
writeColor(L8A8 * dst,const gl::ColorF * src)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
average(L8A8 * dst,const L8A8 * src1,const L8A8 * src2)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
readColor(gl::ColorF * dst,const A8L8 * src)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
writeColor(A8L8 * dst,const gl::ColorF * src)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
average(A8L8 * dst,const A8L8 * src1,const A8L8 * src2)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
readColor(gl::ColorUI * dst,const R8G8 * src)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
readColor(gl::ColorF * dst,const R8G8 * src)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
writeColor(R8G8 * dst,const gl::ColorUI * src)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
writeColor(R8G8 * dst,const gl::ColorF * src)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
average(R8G8 * dst,const R8G8 * src1,const R8G8 * src2)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
readColor(gl::ColorUI * dst,const R8G8B8 * src)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
readColor(gl::ColorF * dst,const R8G8B8 * src)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
writeColor(R8G8B8 * dst,const gl::ColorUI * src)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
writeColor(R8G8B8 * dst,const gl::ColorF * src)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
average(R8G8B8 * dst,const R8G8B8 * src1,const R8G8B8 * src2)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
readColor(gl::ColorUI * dst,const B8G8R8 * src)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
readColor(gl::ColorF * dst,const B8G8R8 * src)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
writeColor(B8G8R8 * dst,const gl::ColorUI * src)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
writeColor(B8G8R8 * dst,const gl::ColorF * src)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
average(B8G8R8 * dst,const B8G8R8 * src1,const B8G8R8 * src2)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
readColor(gl::ColorF * dst,const R5G6B5 * src)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
writeColor(R5G6B5 * dst,const gl::ColorF * src)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
average(R5G6B5 * dst,const R5G6B5 * src1,const R5G6B5 * src2)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
readColor(gl::ColorF * dst,const B5G6R5 * src)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
writeColor(B5G6R5 * dst,const gl::ColorF * src)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
average(B5G6R5 * dst,const B5G6R5 * src1,const B5G6R5 * src2)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
readColor(gl::ColorUI * dst,const A8R8G8B8 * src)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
readColor(gl::ColorF * dst,const A8R8G8B8 * src)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
writeColor(A8R8G8B8 * dst,const gl::ColorUI * src)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
writeColor(A8R8G8B8 * dst,const gl::ColorF * src)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
average(A8R8G8B8 * dst,const A8R8G8B8 * src1,const A8R8G8B8 * src2)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
readColor(gl::ColorUI * dst,const R8G8B8A8 * src)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
readColor(gl::ColorF * dst,const R8G8B8A8 * src)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
writeColor(R8G8B8A8 * dst,const gl::ColorUI * src)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
writeColor(R8G8B8A8 * dst,const gl::ColorF * src)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
average(R8G8B8A8 * dst,const R8G8B8A8 * src1,const R8G8B8A8 * src2)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
readColor(gl::ColorUI * dst,const B8G8R8A8 * src)361 void B8G8R8A8::readColor(gl::ColorUI *dst, const B8G8R8A8 *src)
362 {
363 dst->red = src->R;
364 dst->green = src->G;
365 dst->blue = src->B;
366 dst->alpha = src->A;
367 }
368
readColor(gl::ColorF * dst,const B8G8R8A8 * src)369 void B8G8R8A8::readColor(gl::ColorF *dst, const B8G8R8A8 *src)
370 {
371 dst->red = gl::normalizedToFloat(src->R);
372 dst->green = gl::normalizedToFloat(src->G);
373 dst->blue = gl::normalizedToFloat(src->B);
374 dst->alpha = gl::normalizedToFloat(src->A);
375 }
376
writeColor(B8G8R8A8 * dst,const gl::ColorUI * src)377 void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorUI *src)
378 {
379 dst->R = static_cast<uint8_t>(src->red);
380 dst->G = static_cast<uint8_t>(src->green);
381 dst->B = static_cast<uint8_t>(src->blue);
382 dst->A = static_cast<uint8_t>(src->alpha);
383 }
384
writeColor(B8G8R8A8 * dst,const gl::ColorF * src)385 void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorF *src)
386 {
387 dst->R = gl::floatToNormalized<uint8_t>(src->red);
388 dst->G = gl::floatToNormalized<uint8_t>(src->green);
389 dst->B = gl::floatToNormalized<uint8_t>(src->blue);
390 dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
391 }
392
average(B8G8R8A8 * dst,const B8G8R8A8 * src1,const B8G8R8A8 * src2)393 void B8G8R8A8::average(B8G8R8A8 *dst, const B8G8R8A8 *src1, const B8G8R8A8 *src2)
394 {
395 *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
396 (*(uint32_t *)src1 & *(uint32_t *)src2);
397 }
398
readColor(gl::ColorUI * dst,const B8G8R8X8 * src)399 void B8G8R8X8::readColor(gl::ColorUI *dst, const B8G8R8X8 *src)
400 {
401 dst->red = src->R;
402 dst->green = src->G;
403 dst->blue = src->B;
404 dst->alpha = 1;
405 }
406
readColor(gl::ColorF * dst,const B8G8R8X8 * src)407 void B8G8R8X8::readColor(gl::ColorF *dst, const B8G8R8X8 *src)
408 {
409 dst->red = gl::normalizedToFloat(src->R);
410 dst->green = gl::normalizedToFloat(src->G);
411 dst->blue = gl::normalizedToFloat(src->B);
412 dst->alpha = 1.0f;
413 }
414
writeColor(B8G8R8X8 * dst,const gl::ColorUI * src)415 void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorUI *src)
416 {
417 dst->R = static_cast<uint8_t>(src->red);
418 dst->G = static_cast<uint8_t>(src->green);
419 dst->B = static_cast<uint8_t>(src->blue);
420 dst->X = 255;
421 }
422
writeColor(B8G8R8X8 * dst,const gl::ColorF * src)423 void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorF *src)
424 {
425 dst->R = gl::floatToNormalized<uint8_t>(src->red);
426 dst->G = gl::floatToNormalized<uint8_t>(src->green);
427 dst->B = gl::floatToNormalized<uint8_t>(src->blue);
428 dst->X = 255;
429 }
430
average(B8G8R8X8 * dst,const B8G8R8X8 * src1,const B8G8R8X8 * src2)431 void B8G8R8X8::average(B8G8R8X8 *dst, const B8G8R8X8 *src1, const B8G8R8X8 *src2)
432 {
433 *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
434 (*(uint32_t *)src1 & *(uint32_t *)src2);
435 dst->X = 255;
436 }
437
readColor(gl::ColorF * dst,const A1R5G5B5 * src)438 void A1R5G5B5::readColor(gl::ColorF *dst, const A1R5G5B5 *src)
439 {
440 dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 15>(src->ARGB));
441 dst->red = gl::normalizedToFloat<5>(gl::getShiftedData<5, 10>(src->ARGB));
442 dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5, 5>(src->ARGB));
443 dst->blue = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->ARGB));
444 }
445
writeColor(A1R5G5B5 * dst,const gl::ColorF * src)446 void A1R5G5B5::writeColor(A1R5G5B5 *dst, const gl::ColorF *src)
447 {
448 dst->ARGB = gl::shiftData<1, 15>(gl::floatToNormalized<1, uint16_t>(src->alpha)) |
449 gl::shiftData<5, 10>(gl::floatToNormalized<5, uint16_t>(src->red)) |
450 gl::shiftData<5, 5>(gl::floatToNormalized<5, uint16_t>(src->green)) |
451 gl::shiftData<5, 0>(gl::floatToNormalized<5, uint16_t>(src->blue));
452 }
453
average(A1R5G5B5 * dst,const A1R5G5B5 * src1,const A1R5G5B5 * src2)454 void A1R5G5B5::average(A1R5G5B5 *dst, const A1R5G5B5 *src1, const A1R5G5B5 *src2)
455 {
456 dst->ARGB = gl::shiftData<1, 15>(gl::average(gl::getShiftedData<1, 15>(src1->ARGB),
457 gl::getShiftedData<1, 15>(src2->ARGB))) |
458 gl::shiftData<5, 10>(gl::average(gl::getShiftedData<5, 10>(src1->ARGB),
459 gl::getShiftedData<5, 10>(src2->ARGB))) |
460 gl::shiftData<5, 5>(gl::average(gl::getShiftedData<5, 5>(src1->ARGB),
461 gl::getShiftedData<5, 5>(src2->ARGB))) |
462 gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->ARGB),
463 gl::getShiftedData<5, 0>(src2->ARGB)));
464 }
465
readColor(gl::ColorF * dst,const R5G5B5A1 * src)466 void R5G5B5A1::readColor(gl::ColorF *dst, const R5G5B5A1 *src)
467 {
468 dst->red = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->RGBA));
469 dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5, 6>(src->RGBA));
470 dst->blue = gl::normalizedToFloat<5>(gl::getShiftedData<5, 1>(src->RGBA));
471 dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 0>(src->RGBA));
472 }
473
writeColor(R5G5B5A1 * dst,const gl::ColorF * src)474 void R5G5B5A1::writeColor(R5G5B5A1 *dst, const gl::ColorF *src)
475 {
476 dst->RGBA = gl::shiftData<5, 11>(gl::floatToNormalized<5, uint16_t>(src->red)) |
477 gl::shiftData<5, 6>(gl::floatToNormalized<5, uint16_t>(src->green)) |
478 gl::shiftData<5, 1>(gl::floatToNormalized<5, uint16_t>(src->blue)) |
479 gl::shiftData<1, 0>(gl::floatToNormalized<1, uint16_t>(src->alpha));
480 }
481
average(R5G5B5A1 * dst,const R5G5B5A1 * src1,const R5G5B5A1 * src2)482 void R5G5B5A1::average(R5G5B5A1 *dst, const R5G5B5A1 *src1, const R5G5B5A1 *src2)
483 {
484 dst->RGBA = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->RGBA),
485 gl::getShiftedData<5, 11>(src2->RGBA))) |
486 gl::shiftData<5, 6>(gl::average(gl::getShiftedData<5, 6>(src1->RGBA),
487 gl::getShiftedData<5, 6>(src2->RGBA))) |
488 gl::shiftData<5, 1>(gl::average(gl::getShiftedData<5, 1>(src1->RGBA),
489 gl::getShiftedData<5, 1>(src2->RGBA))) |
490 gl::shiftData<1, 0>(gl::average(gl::getShiftedData<1, 0>(src1->RGBA),
491 gl::getShiftedData<1, 0>(src2->RGBA)));
492 }
493
readColor(gl::ColorF * dst,const R4G4B4A4 * src)494 void R4G4B4A4::readColor(gl::ColorF *dst, const R4G4B4A4 *src)
495 {
496 dst->red = gl::normalizedToFloat<4>(gl::getShiftedData<4, 12>(src->RGBA));
497 dst->green = gl::normalizedToFloat<4>(gl::getShiftedData<4, 8>(src->RGBA));
498 dst->blue = gl::normalizedToFloat<4>(gl::getShiftedData<4, 4>(src->RGBA));
499 dst->alpha = gl::normalizedToFloat<4>(gl::getShiftedData<4, 0>(src->RGBA));
500 }
501
writeColor(R4G4B4A4 * dst,const gl::ColorF * src)502 void R4G4B4A4::writeColor(R4G4B4A4 *dst, const gl::ColorF *src)
503 {
504 dst->RGBA = gl::shiftData<4, 12>(gl::floatToNormalized<4, uint16_t>(src->red)) |
505 gl::shiftData<4, 8>(gl::floatToNormalized<4, uint16_t>(src->green)) |
506 gl::shiftData<4, 4>(gl::floatToNormalized<4, uint16_t>(src->blue)) |
507 gl::shiftData<4, 0>(gl::floatToNormalized<4, uint16_t>(src->alpha));
508 }
509
average(R4G4B4A4 * dst,const R4G4B4A4 * src1,const R4G4B4A4 * src2)510 void R4G4B4A4::average(R4G4B4A4 *dst, const R4G4B4A4 *src1, const R4G4B4A4 *src2)
511 {
512 dst->RGBA = gl::shiftData<4, 12>(gl::average(gl::getShiftedData<4, 12>(src1->RGBA),
513 gl::getShiftedData<4, 12>(src2->RGBA))) |
514 gl::shiftData<4, 8>(gl::average(gl::getShiftedData<4, 8>(src1->RGBA),
515 gl::getShiftedData<4, 8>(src2->RGBA))) |
516 gl::shiftData<4, 4>(gl::average(gl::getShiftedData<4, 4>(src1->RGBA),
517 gl::getShiftedData<4, 4>(src2->RGBA))) |
518 gl::shiftData<4, 0>(gl::average(gl::getShiftedData<4, 0>(src1->RGBA),
519 gl::getShiftedData<4, 0>(src2->RGBA)));
520 }
521
readColor(gl::ColorF * dst,const A4R4G4B4 * src)522 void A4R4G4B4::readColor(gl::ColorF *dst, const A4R4G4B4 *src)
523 {
524 dst->alpha = gl::normalizedToFloat<4>(gl::getShiftedData<4, 12>(src->ARGB));
525 dst->red = gl::normalizedToFloat<4>(gl::getShiftedData<4, 8>(src->ARGB));
526 dst->green = gl::normalizedToFloat<4>(gl::getShiftedData<4, 4>(src->ARGB));
527 dst->blue = gl::normalizedToFloat<4>(gl::getShiftedData<4, 0>(src->ARGB));
528 }
529
writeColor(A4R4G4B4 * dst,const gl::ColorF * src)530 void A4R4G4B4::writeColor(A4R4G4B4 *dst, const gl::ColorF *src)
531 {
532 dst->ARGB = gl::shiftData<4, 12>(gl::floatToNormalized<4, uint16_t>(src->alpha)) |
533 gl::shiftData<4, 8>(gl::floatToNormalized<4, uint16_t>(src->red)) |
534 gl::shiftData<4, 4>(gl::floatToNormalized<4, uint16_t>(src->green)) |
535 gl::shiftData<4, 0>(gl::floatToNormalized<4, uint16_t>(src->blue));
536 }
537
average(A4R4G4B4 * dst,const A4R4G4B4 * src1,const A4R4G4B4 * src2)538 void A4R4G4B4::average(A4R4G4B4 *dst, const A4R4G4B4 *src1, const A4R4G4B4 *src2)
539 {
540 dst->ARGB = gl::shiftData<4, 12>(gl::average(gl::getShiftedData<4, 12>(src1->ARGB),
541 gl::getShiftedData<4, 12>(src2->ARGB))) |
542 gl::shiftData<4, 8>(gl::average(gl::getShiftedData<4, 8>(src1->ARGB),
543 gl::getShiftedData<4, 8>(src2->ARGB))) |
544 gl::shiftData<4, 4>(gl::average(gl::getShiftedData<4, 4>(src1->ARGB),
545 gl::getShiftedData<4, 4>(src2->ARGB))) |
546 gl::shiftData<4, 0>(gl::average(gl::getShiftedData<4, 0>(src1->ARGB),
547 gl::getShiftedData<4, 0>(src2->ARGB)));
548 }
549
readColor(gl::ColorUI * dst,const R16 * src)550 void R16::readColor(gl::ColorUI *dst, const R16 *src)
551 {
552 dst->red = src->R;
553 dst->green = 0;
554 dst->blue = 0;
555 dst->alpha = 1;
556 }
557
readColor(gl::ColorF * dst,const R16 * src)558 void R16::readColor(gl::ColorF *dst, const R16 *src)
559 {
560 dst->red = gl::normalizedToFloat(src->R);
561 dst->green = 0.0f;
562 dst->blue = 0.0f;
563 dst->alpha = 1.0f;
564 }
565
writeColor(R16 * dst,const gl::ColorUI * src)566 void R16::writeColor(R16 *dst, const gl::ColorUI *src)
567 {
568 dst->R = static_cast<uint16_t>(src->red);
569 }
570
writeColor(R16 * dst,const gl::ColorF * src)571 void R16::writeColor(R16 *dst, const gl::ColorF *src)
572 {
573 dst->R = gl::floatToNormalized<uint16_t>(src->red);
574 }
575
average(R16 * dst,const R16 * src1,const R16 * src2)576 void R16::average(R16 *dst, const R16 *src1, const R16 *src2)
577 {
578 dst->R = gl::average(src1->R, src2->R);
579 }
580
readColor(gl::ColorUI * dst,const R16G16 * src)581 void R16G16::readColor(gl::ColorUI *dst, const R16G16 *src)
582 {
583 dst->red = src->R;
584 dst->green = src->G;
585 dst->blue = 0;
586 dst->alpha = 1;
587 }
588
readColor(gl::ColorF * dst,const R16G16 * src)589 void R16G16::readColor(gl::ColorF *dst, const R16G16 *src)
590 {
591 dst->red = gl::normalizedToFloat(src->R);
592 dst->green = gl::normalizedToFloat(src->G);
593 dst->blue = 0.0f;
594 dst->alpha = 1.0f;
595 }
596
writeColor(R16G16 * dst,const gl::ColorUI * src)597 void R16G16::writeColor(R16G16 *dst, const gl::ColorUI *src)
598 {
599 dst->R = static_cast<uint16_t>(src->red);
600 dst->G = static_cast<uint16_t>(src->green);
601 }
602
writeColor(R16G16 * dst,const gl::ColorF * src)603 void R16G16::writeColor(R16G16 *dst, const gl::ColorF *src)
604 {
605 dst->R = gl::floatToNormalized<uint16_t>(src->red);
606 dst->G = gl::floatToNormalized<uint16_t>(src->green);
607 }
608
average(R16G16 * dst,const R16G16 * src1,const R16G16 * src2)609 void R16G16::average(R16G16 *dst, const R16G16 *src1, const R16G16 *src2)
610 {
611 dst->R = gl::average(src1->R, src2->R);
612 dst->G = gl::average(src1->G, src2->G);
613 }
614
readColor(gl::ColorUI * dst,const R16G16B16 * src)615 void R16G16B16::readColor(gl::ColorUI *dst, const R16G16B16 *src)
616 {
617 dst->red = src->R;
618 dst->green = src->G;
619 dst->blue = src->B;
620 dst->alpha = 1;
621 }
622
readColor(gl::ColorF * dst,const R16G16B16 * src)623 void R16G16B16::readColor(gl::ColorF *dst, const R16G16B16 *src)
624 {
625 dst->red = gl::normalizedToFloat(src->R);
626 dst->green = gl::normalizedToFloat(src->G);
627 dst->blue = gl::normalizedToFloat(src->B);
628 dst->alpha = 1.0f;
629 }
630
writeColor(R16G16B16 * dst,const gl::ColorUI * src)631 void R16G16B16::writeColor(R16G16B16 *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 dst->B = static_cast<uint16_t>(src->blue);
636 }
637
writeColor(R16G16B16 * dst,const gl::ColorF * src)638 void R16G16B16::writeColor(R16G16B16 *dst, const gl::ColorF *src)
639 {
640 dst->R = gl::floatToNormalized<uint16_t>(src->red);
641 dst->G = gl::floatToNormalized<uint16_t>(src->green);
642 dst->B = gl::floatToNormalized<uint16_t>(src->blue);
643 }
644
average(R16G16B16 * dst,const R16G16B16 * src1,const R16G16B16 * src2)645 void R16G16B16::average(R16G16B16 *dst, const R16G16B16 *src1, const R16G16B16 *src2)
646 {
647 dst->R = gl::average(src1->R, src2->R);
648 dst->G = gl::average(src1->G, src2->G);
649 dst->B = gl::average(src1->B, src2->B);
650 }
651
readColor(gl::ColorUI * dst,const R16G16B16A16 * src)652 void R16G16B16A16::readColor(gl::ColorUI *dst, const R16G16B16A16 *src)
653 {
654 dst->red = src->R;
655 dst->green = src->G;
656 dst->blue = src->B;
657 dst->alpha = src->A;
658 }
659
readColor(gl::ColorF * dst,const R16G16B16A16 * src)660 void R16G16B16A16::readColor(gl::ColorF *dst, const R16G16B16A16 *src)
661 {
662 dst->red = gl::normalizedToFloat(src->R);
663 dst->green = gl::normalizedToFloat(src->G);
664 dst->blue = gl::normalizedToFloat(src->B);
665 dst->alpha = gl::normalizedToFloat(src->A);
666 }
667
writeColor(R16G16B16A16 * dst,const gl::ColorUI * src)668 void R16G16B16A16::writeColor(R16G16B16A16 *dst, const gl::ColorUI *src)
669 {
670 dst->R = static_cast<uint16_t>(src->red);
671 dst->G = static_cast<uint16_t>(src->green);
672 dst->B = static_cast<uint16_t>(src->blue);
673 dst->A = static_cast<uint16_t>(src->alpha);
674 }
675
writeColor(R16G16B16A16 * dst,const gl::ColorF * src)676 void R16G16B16A16::writeColor(R16G16B16A16 *dst, const gl::ColorF *src)
677 {
678 dst->R = gl::floatToNormalized<uint16_t>(src->red);
679 dst->G = gl::floatToNormalized<uint16_t>(src->green);
680 dst->B = gl::floatToNormalized<uint16_t>(src->blue);
681 dst->A = gl::floatToNormalized<uint16_t>(src->alpha);
682 }
683
average(R16G16B16A16 * dst,const R16G16B16A16 * src1,const R16G16B16A16 * src2)684 void R16G16B16A16::average(R16G16B16A16 *dst, const R16G16B16A16 *src1, const R16G16B16A16 *src2)
685 {
686 dst->R = gl::average(src1->R, src2->R);
687 dst->G = gl::average(src1->G, src2->G);
688 dst->B = gl::average(src1->B, src2->B);
689 dst->A = gl::average(src1->A, src2->A);
690 }
691
readColor(gl::ColorUI * dst,const R32 * src)692 void R32::readColor(gl::ColorUI *dst, const R32 *src)
693 {
694 dst->red = src->R;
695 dst->green = 0;
696 dst->blue = 0;
697 dst->alpha = 1;
698 }
699
readColor(gl::ColorF * dst,const R32 * src)700 void R32::readColor(gl::ColorF *dst, const R32 *src)
701 {
702 dst->red = gl::normalizedToFloat(src->R);
703 dst->green = 0.0f;
704 dst->blue = 0.0f;
705 dst->alpha = 1.0f;
706 }
707
writeColor(R32 * dst,const gl::ColorUI * src)708 void R32::writeColor(R32 *dst, const gl::ColorUI *src)
709 {
710 dst->R = static_cast<uint32_t>(src->red);
711 }
712
writeColor(R32 * dst,const gl::ColorF * src)713 void R32::writeColor(R32 *dst, const gl::ColorF *src)
714 {
715 dst->R = gl::floatToNormalized<uint32_t>(src->red);
716 }
717
average(R32 * dst,const R32 * src1,const R32 * src2)718 void R32::average(R32 *dst, const R32 *src1, const R32 *src2)
719 {
720 dst->R = gl::average(src1->R, src2->R);
721 }
722
readColor(gl::ColorUI * dst,const R32G32 * src)723 void R32G32::readColor(gl::ColorUI *dst, const R32G32 *src)
724 {
725 dst->red = src->R;
726 dst->green = src->G;
727 dst->blue = 0;
728 dst->alpha = 1;
729 }
730
readColor(gl::ColorF * dst,const R32G32 * src)731 void R32G32::readColor(gl::ColorF *dst, const R32G32 *src)
732 {
733 dst->red = gl::normalizedToFloat(src->R);
734 dst->green = gl::normalizedToFloat(src->G);
735 dst->blue = 0.0f;
736 dst->alpha = 1.0f;
737 }
738
writeColor(R32G32 * dst,const gl::ColorUI * src)739 void R32G32::writeColor(R32G32 *dst, const gl::ColorUI *src)
740 {
741 dst->R = static_cast<uint32_t>(src->red);
742 dst->G = static_cast<uint32_t>(src->green);
743 }
744
writeColor(R32G32 * dst,const gl::ColorF * src)745 void R32G32::writeColor(R32G32 *dst, const gl::ColorF *src)
746 {
747 dst->R = gl::floatToNormalized<uint32_t>(src->red);
748 dst->G = gl::floatToNormalized<uint32_t>(src->green);
749 }
750
average(R32G32 * dst,const R32G32 * src1,const R32G32 * src2)751 void R32G32::average(R32G32 *dst, const R32G32 *src1, const R32G32 *src2)
752 {
753 dst->R = gl::average(src1->R, src2->R);
754 dst->G = gl::average(src1->G, src2->G);
755 }
756
readColor(gl::ColorUI * dst,const R32G32B32 * src)757 void R32G32B32::readColor(gl::ColorUI *dst, const R32G32B32 *src)
758 {
759 dst->red = src->R;
760 dst->green = src->G;
761 dst->blue = src->B;
762 dst->alpha = 1;
763 }
764
readColor(gl::ColorF * dst,const R32G32B32 * src)765 void R32G32B32::readColor(gl::ColorF *dst, const R32G32B32 *src)
766 {
767 dst->red = gl::normalizedToFloat(src->R);
768 dst->green = gl::normalizedToFloat(src->G);
769 dst->blue = gl::normalizedToFloat(src->B);
770 dst->alpha = 1.0f;
771 }
772
writeColor(R32G32B32 * dst,const gl::ColorUI * src)773 void R32G32B32::writeColor(R32G32B32 *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 dst->B = static_cast<uint32_t>(src->blue);
778 }
779
writeColor(R32G32B32 * dst,const gl::ColorF * src)780 void R32G32B32::writeColor(R32G32B32 *dst, const gl::ColorF *src)
781 {
782 dst->R = gl::floatToNormalized<uint32_t>(src->red);
783 dst->G = gl::floatToNormalized<uint32_t>(src->green);
784 dst->B = gl::floatToNormalized<uint32_t>(src->blue);
785 }
786
average(R32G32B32 * dst,const R32G32B32 * src1,const R32G32B32 * src2)787 void R32G32B32::average(R32G32B32 *dst, const R32G32B32 *src1, const R32G32B32 *src2)
788 {
789 dst->R = gl::average(src1->R, src2->R);
790 dst->G = gl::average(src1->G, src2->G);
791 dst->B = gl::average(src1->B, src2->B);
792 }
793
readColor(gl::ColorUI * dst,const R32G32B32A32 * src)794 void R32G32B32A32::readColor(gl::ColorUI *dst, const R32G32B32A32 *src)
795 {
796 dst->red = src->R;
797 dst->green = src->G;
798 dst->blue = src->B;
799 dst->alpha = src->A;
800 }
801
readColor(gl::ColorF * dst,const R32G32B32A32 * src)802 void R32G32B32A32::readColor(gl::ColorF *dst, const R32G32B32A32 *src)
803 {
804 dst->red = gl::normalizedToFloat(src->R);
805 dst->green = gl::normalizedToFloat(src->G);
806 dst->blue = gl::normalizedToFloat(src->B);
807 dst->alpha = gl::normalizedToFloat(src->A);
808 }
809
writeColor(R32G32B32A32 * dst,const gl::ColorUI * src)810 void R32G32B32A32::writeColor(R32G32B32A32 *dst, const gl::ColorUI *src)
811 {
812 dst->R = static_cast<uint32_t>(src->red);
813 dst->G = static_cast<uint32_t>(src->green);
814 dst->B = static_cast<uint32_t>(src->blue);
815 dst->A = static_cast<uint32_t>(src->alpha);
816 }
817
writeColor(R32G32B32A32 * dst,const gl::ColorF * src)818 void R32G32B32A32::writeColor(R32G32B32A32 *dst, const gl::ColorF *src)
819 {
820 dst->R = gl::floatToNormalized<uint32_t>(src->red);
821 dst->G = gl::floatToNormalized<uint32_t>(src->green);
822 dst->B = gl::floatToNormalized<uint32_t>(src->blue);
823 dst->A = gl::floatToNormalized<uint32_t>(src->alpha);
824 }
825
average(R32G32B32A32 * dst,const R32G32B32A32 * src1,const R32G32B32A32 * src2)826 void R32G32B32A32::average(R32G32B32A32 *dst, const R32G32B32A32 *src1, const R32G32B32A32 *src2)
827 {
828 dst->R = gl::average(src1->R, src2->R);
829 dst->G = gl::average(src1->G, src2->G);
830 dst->B = gl::average(src1->B, src2->B);
831 dst->A = gl::average(src1->A, src2->A);
832 }
833
readColor(gl::ColorI * dst,const R8S * src)834 void R8S::readColor(gl::ColorI *dst, const R8S *src)
835 {
836 dst->red = src->R;
837 dst->green = 0;
838 dst->blue = 0;
839 dst->alpha = 1;
840 }
841
readColor(gl::ColorF * dst,const R8S * src)842 void R8S::readColor(gl::ColorF *dst, const R8S *src)
843 {
844 dst->red = gl::normalizedToFloat(src->R);
845 dst->green = 0.0f;
846 dst->blue = 0.0f;
847 dst->alpha = 1.0f;
848 }
849
writeColor(R8S * dst,const gl::ColorI * src)850 void R8S::writeColor(R8S *dst, const gl::ColorI *src)
851 {
852 dst->R = static_cast<int8_t>(src->red);
853 }
854
writeColor(R8S * dst,const gl::ColorF * src)855 void R8S::writeColor(R8S *dst, const gl::ColorF *src)
856 {
857 dst->R = gl::floatToNormalized<int8_t>(src->red);
858 }
859
average(R8S * dst,const R8S * src1,const R8S * src2)860 void R8S::average(R8S *dst, const R8S *src1, const R8S *src2)
861 {
862 dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
863 }
864
readColor(gl::ColorI * dst,const R8G8S * src)865 void R8G8S::readColor(gl::ColorI *dst, const R8G8S *src)
866 {
867 dst->red = src->R;
868 dst->green = src->G;
869 dst->blue = 0;
870 dst->alpha = 1;
871 }
872
readColor(gl::ColorF * dst,const R8G8S * src)873 void R8G8S::readColor(gl::ColorF *dst, const R8G8S *src)
874 {
875 dst->red = gl::normalizedToFloat(src->R);
876 dst->green = gl::normalizedToFloat(src->G);
877 dst->blue = 0.0f;
878 dst->alpha = 1.0f;
879 }
880
writeColor(R8G8S * dst,const gl::ColorI * src)881 void R8G8S::writeColor(R8G8S *dst, const gl::ColorI *src)
882 {
883 dst->R = static_cast<int8_t>(src->red);
884 dst->G = static_cast<int8_t>(src->green);
885 }
886
writeColor(R8G8S * dst,const gl::ColorF * src)887 void R8G8S::writeColor(R8G8S *dst, const gl::ColorF *src)
888 {
889 dst->R = gl::floatToNormalized<int8_t>(src->red);
890 dst->G = gl::floatToNormalized<int8_t>(src->green);
891 }
892
average(R8G8S * dst,const R8G8S * src1,const R8G8S * src2)893 void R8G8S::average(R8G8S *dst, const R8G8S *src1, const R8G8S *src2)
894 {
895 dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
896 dst->G = static_cast<int8_t>(gl::average(src1->G, src2->G));
897 }
898
readColor(gl::ColorI * dst,const R8G8B8S * src)899 void R8G8B8S::readColor(gl::ColorI *dst, const R8G8B8S *src)
900 {
901 dst->red = src->R;
902 dst->green = src->G;
903 dst->blue = src->B;
904 dst->alpha = 1;
905 }
906
readColor(gl::ColorF * dst,const R8G8B8S * src)907 void R8G8B8S::readColor(gl::ColorF *dst, const R8G8B8S *src)
908 {
909 dst->red = gl::normalizedToFloat(src->R);
910 dst->green = gl::normalizedToFloat(src->G);
911 dst->blue = gl::normalizedToFloat(src->B);
912 dst->alpha = 1.0f;
913 }
914
writeColor(R8G8B8S * dst,const gl::ColorI * src)915 void R8G8B8S::writeColor(R8G8B8S *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 dst->B = static_cast<int8_t>(src->blue);
920 }
921
writeColor(R8G8B8S * dst,const gl::ColorF * src)922 void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorF *src)
923 {
924 dst->R = gl::floatToNormalized<int8_t>(src->red);
925 dst->G = gl::floatToNormalized<int8_t>(src->green);
926 dst->B = gl::floatToNormalized<int8_t>(src->blue);
927 }
928
average(R8G8B8S * dst,const R8G8B8S * src1,const R8G8B8S * src2)929 void R8G8B8S::average(R8G8B8S *dst, const R8G8B8S *src1, const R8G8B8S *src2)
930 {
931 dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
932 dst->G = static_cast<int8_t>(gl::average(src1->G, src2->G));
933 dst->B = static_cast<int8_t>(gl::average(src1->B, src2->B));
934 }
935
readColor(gl::ColorI * dst,const R8G8B8A8S * src)936 void R8G8B8A8S::readColor(gl::ColorI *dst, const R8G8B8A8S *src)
937 {
938 dst->red = src->R;
939 dst->green = src->G;
940 dst->blue = src->B;
941 dst->alpha = src->A;
942 }
943
readColor(gl::ColorF * dst,const R8G8B8A8S * src)944 void R8G8B8A8S::readColor(gl::ColorF *dst, const R8G8B8A8S *src)
945 {
946 dst->red = gl::normalizedToFloat(src->R);
947 dst->green = gl::normalizedToFloat(src->G);
948 dst->blue = gl::normalizedToFloat(src->B);
949 dst->alpha = gl::normalizedToFloat(src->A);
950 }
951
writeColor(R8G8B8A8S * dst,const gl::ColorI * src)952 void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorI *src)
953 {
954 dst->R = static_cast<int8_t>(src->red);
955 dst->G = static_cast<int8_t>(src->green);
956 dst->B = static_cast<int8_t>(src->blue);
957 dst->A = static_cast<int8_t>(src->alpha);
958 }
959
writeColor(R8G8B8A8S * dst,const gl::ColorF * src)960 void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorF *src)
961 {
962 dst->R = gl::floatToNormalized<int8_t>(src->red);
963 dst->G = gl::floatToNormalized<int8_t>(src->green);
964 dst->B = gl::floatToNormalized<int8_t>(src->blue);
965 dst->A = gl::floatToNormalized<int8_t>(src->alpha);
966 }
967
average(R8G8B8A8S * dst,const R8G8B8A8S * src1,const R8G8B8A8S * src2)968 void R8G8B8A8S::average(R8G8B8A8S *dst, const R8G8B8A8S *src1, const R8G8B8A8S *src2)
969 {
970 dst->R = static_cast<int8_t>(gl::average(src1->R, src2->R));
971 dst->G = static_cast<int8_t>(gl::average(src1->G, src2->G));
972 dst->B = static_cast<int8_t>(gl::average(src1->B, src2->B));
973 dst->A = static_cast<int8_t>(gl::average(src1->A, src2->A));
974 }
975
readColor(gl::ColorI * dst,const R16S * src)976 void R16S::readColor(gl::ColorI *dst, const R16S *src)
977 {
978 dst->red = src->R;
979 dst->green = 0;
980 dst->blue = 0;
981 dst->alpha = 1;
982 }
983
readColor(gl::ColorF * dst,const R16S * src)984 void R16S::readColor(gl::ColorF *dst, const R16S *src)
985 {
986 dst->red = gl::normalizedToFloat(src->R);
987 dst->green = 0.0f;
988 dst->blue = 0.0f;
989 dst->alpha = 1.0f;
990 }
991
writeColor(R16S * dst,const gl::ColorI * src)992 void R16S::writeColor(R16S *dst, const gl::ColorI *src)
993 {
994 dst->R = static_cast<int16_t>(src->red);
995 }
996
writeColor(R16S * dst,const gl::ColorF * src)997 void R16S::writeColor(R16S *dst, const gl::ColorF *src)
998 {
999 dst->R = gl::floatToNormalized<int16_t>(src->red);
1000 }
1001
average(R16S * dst,const R16S * src1,const R16S * src2)1002 void R16S::average(R16S *dst, const R16S *src1, const R16S *src2)
1003 {
1004 dst->R = gl::average(src1->R, src2->R);
1005 }
1006
readColor(gl::ColorI * dst,const R16G16S * src)1007 void R16G16S::readColor(gl::ColorI *dst, const R16G16S *src)
1008 {
1009 dst->red = src->R;
1010 dst->green = src->G;
1011 dst->blue = 0;
1012 dst->alpha = 1;
1013 }
1014
readColor(gl::ColorF * dst,const R16G16S * src)1015 void R16G16S::readColor(gl::ColorF *dst, const R16G16S *src)
1016 {
1017 dst->red = gl::normalizedToFloat(src->R);
1018 dst->green = gl::normalizedToFloat(src->G);
1019 dst->blue = 0.0f;
1020 dst->alpha = 1.0f;
1021 }
1022
writeColor(R16G16S * dst,const gl::ColorI * src)1023 void R16G16S::writeColor(R16G16S *dst, const gl::ColorI *src)
1024 {
1025 dst->R = static_cast<int16_t>(src->red);
1026 dst->G = static_cast<int16_t>(src->green);
1027 }
1028
writeColor(R16G16S * dst,const gl::ColorF * src)1029 void R16G16S::writeColor(R16G16S *dst, const gl::ColorF *src)
1030 {
1031 dst->R = gl::floatToNormalized<int16_t>(src->red);
1032 dst->G = gl::floatToNormalized<int16_t>(src->green);
1033 }
1034
average(R16G16S * dst,const R16G16S * src1,const R16G16S * src2)1035 void R16G16S::average(R16G16S *dst, const R16G16S *src1, const R16G16S *src2)
1036 {
1037 dst->R = gl::average(src1->R, src2->R);
1038 dst->G = gl::average(src1->G, src2->G);
1039 }
1040
readColor(gl::ColorI * dst,const R16G16B16S * src)1041 void R16G16B16S::readColor(gl::ColorI *dst, const R16G16B16S *src)
1042 {
1043 dst->red = src->R;
1044 dst->green = src->G;
1045 dst->blue = src->B;
1046 dst->alpha = 1;
1047 }
1048
readColor(gl::ColorF * dst,const R16G16B16S * src)1049 void R16G16B16S::readColor(gl::ColorF *dst, const R16G16B16S *src)
1050 {
1051 dst->red = gl::normalizedToFloat(src->R);
1052 dst->green = gl::normalizedToFloat(src->G);
1053 dst->blue = gl::normalizedToFloat(src->B);
1054 dst->alpha = 1.0f;
1055 }
1056
writeColor(R16G16B16S * dst,const gl::ColorI * src)1057 void R16G16B16S::writeColor(R16G16B16S *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 dst->B = static_cast<int16_t>(src->blue);
1062 }
1063
writeColor(R16G16B16S * dst,const gl::ColorF * src)1064 void R16G16B16S::writeColor(R16G16B16S *dst, const gl::ColorF *src)
1065 {
1066 dst->R = gl::floatToNormalized<int16_t>(src->red);
1067 dst->G = gl::floatToNormalized<int16_t>(src->green);
1068 dst->B = gl::floatToNormalized<int16_t>(src->blue);
1069 }
1070
average(R16G16B16S * dst,const R16G16B16S * src1,const R16G16B16S * src2)1071 void R16G16B16S::average(R16G16B16S *dst, const R16G16B16S *src1, const R16G16B16S *src2)
1072 {
1073 dst->R = gl::average(src1->R, src2->R);
1074 dst->G = gl::average(src1->G, src2->G);
1075 dst->B = gl::average(src1->B, src2->B);
1076 }
1077
readColor(gl::ColorI * dst,const R16G16B16A16S * src)1078 void R16G16B16A16S::readColor(gl::ColorI *dst, const R16G16B16A16S *src)
1079 {
1080 dst->red = src->R;
1081 dst->green = src->G;
1082 dst->blue = src->B;
1083 dst->alpha = src->A;
1084 }
1085
readColor(gl::ColorF * dst,const R16G16B16A16S * src)1086 void R16G16B16A16S::readColor(gl::ColorF *dst, const R16G16B16A16S *src)
1087 {
1088 dst->red = gl::normalizedToFloat(src->R);
1089 dst->green = gl::normalizedToFloat(src->G);
1090 dst->blue = gl::normalizedToFloat(src->B);
1091 dst->alpha = gl::normalizedToFloat(src->A);
1092 }
1093
writeColor(R16G16B16A16S * dst,const gl::ColorI * src)1094 void R16G16B16A16S::writeColor(R16G16B16A16S *dst, const gl::ColorI *src)
1095 {
1096 dst->R = static_cast<int16_t>(src->red);
1097 dst->G = static_cast<int16_t>(src->green);
1098 dst->B = static_cast<int16_t>(src->blue);
1099 dst->A = static_cast<int16_t>(src->alpha);
1100 }
1101
writeColor(R16G16B16A16S * dst,const gl::ColorF * src)1102 void R16G16B16A16S::writeColor(R16G16B16A16S *dst, const gl::ColorF *src)
1103 {
1104 dst->R = gl::floatToNormalized<int16_t>(src->red);
1105 dst->G = gl::floatToNormalized<int16_t>(src->green);
1106 dst->B = gl::floatToNormalized<int16_t>(src->blue);
1107 dst->A = gl::floatToNormalized<int16_t>(src->alpha);
1108 }
1109
average(R16G16B16A16S * dst,const R16G16B16A16S * src1,const R16G16B16A16S * src2)1110 void R16G16B16A16S::average(R16G16B16A16S *dst,
1111 const R16G16B16A16S *src1,
1112 const R16G16B16A16S *src2)
1113 {
1114 dst->R = gl::average(src1->R, src2->R);
1115 dst->G = gl::average(src1->G, src2->G);
1116 dst->B = gl::average(src1->B, src2->B);
1117 dst->A = gl::average(src1->A, src2->A);
1118 }
1119
readColor(gl::ColorI * dst,const R32S * src)1120 void R32S::readColor(gl::ColorI *dst, const R32S *src)
1121 {
1122 dst->red = src->R;
1123 dst->green = 0;
1124 dst->blue = 0;
1125 dst->alpha = 1;
1126 }
1127
readColor(gl::ColorF * dst,const R32S * src)1128 void R32S::readColor(gl::ColorF *dst, const R32S *src)
1129 {
1130 dst->red = gl::normalizedToFloat(src->R);
1131 dst->green = 0.0f;
1132 dst->blue = 0.0f;
1133 dst->alpha = 1.0f;
1134 }
1135
writeColor(R32S * dst,const gl::ColorI * src)1136 void R32S::writeColor(R32S *dst, const gl::ColorI *src)
1137 {
1138 dst->R = static_cast<int32_t>(src->red);
1139 }
1140
writeColor(R32S * dst,const gl::ColorF * src)1141 void R32S::writeColor(R32S *dst, const gl::ColorF *src)
1142 {
1143 dst->R = gl::floatToNormalized<int32_t>(src->red);
1144 }
1145
average(R32S * dst,const R32S * src1,const R32S * src2)1146 void R32S::average(R32S *dst, const R32S *src1, const R32S *src2)
1147 {
1148 dst->R = gl::average(src1->R, src2->R);
1149 }
1150
readColor(gl::ColorI * dst,const R32G32S * src)1151 void R32G32S::readColor(gl::ColorI *dst, const R32G32S *src)
1152 {
1153 dst->red = src->R;
1154 dst->green = src->G;
1155 dst->blue = 0;
1156 dst->alpha = 1;
1157 }
1158
readColor(gl::ColorF * dst,const R32G32S * src)1159 void R32G32S::readColor(gl::ColorF *dst, const R32G32S *src)
1160 {
1161 dst->red = gl::normalizedToFloat(src->R);
1162 dst->green = gl::normalizedToFloat(src->G);
1163 dst->blue = 0.0f;
1164 dst->alpha = 1.0f;
1165 }
1166
writeColor(R32G32S * dst,const gl::ColorI * src)1167 void R32G32S::writeColor(R32G32S *dst, const gl::ColorI *src)
1168 {
1169 dst->R = static_cast<int32_t>(src->red);
1170 dst->G = static_cast<int32_t>(src->green);
1171 }
1172
writeColor(R32G32S * dst,const gl::ColorF * src)1173 void R32G32S::writeColor(R32G32S *dst, const gl::ColorF *src)
1174 {
1175 dst->R = gl::floatToNormalized<int32_t>(src->red);
1176 dst->G = gl::floatToNormalized<int32_t>(src->green);
1177 }
1178
average(R32G32S * dst,const R32G32S * src1,const R32G32S * src2)1179 void R32G32S::average(R32G32S *dst, const R32G32S *src1, const R32G32S *src2)
1180 {
1181 dst->R = gl::average(src1->R, src2->R);
1182 dst->G = gl::average(src1->G, src2->G);
1183 }
1184
readColor(gl::ColorI * dst,const R32G32B32S * src)1185 void R32G32B32S::readColor(gl::ColorI *dst, const R32G32B32S *src)
1186 {
1187 dst->red = src->R;
1188 dst->green = src->G;
1189 dst->blue = src->B;
1190 dst->alpha = 1;
1191 }
1192
readColor(gl::ColorF * dst,const R32G32B32S * src)1193 void R32G32B32S::readColor(gl::ColorF *dst, const R32G32B32S *src)
1194 {
1195 dst->red = gl::normalizedToFloat(src->R);
1196 dst->green = gl::normalizedToFloat(src->G);
1197 dst->blue = gl::normalizedToFloat(src->B);
1198 dst->alpha = 1.0f;
1199 }
1200
writeColor(R32G32B32S * dst,const gl::ColorI * src)1201 void R32G32B32S::writeColor(R32G32B32S *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 dst->B = static_cast<int32_t>(src->blue);
1206 }
1207
writeColor(R32G32B32S * dst,const gl::ColorF * src)1208 void R32G32B32S::writeColor(R32G32B32S *dst, const gl::ColorF *src)
1209 {
1210 dst->R = gl::floatToNormalized<int32_t>(src->red);
1211 dst->G = gl::floatToNormalized<int32_t>(src->green);
1212 dst->B = gl::floatToNormalized<int32_t>(src->blue);
1213 }
1214
average(R32G32B32S * dst,const R32G32B32S * src1,const R32G32B32S * src2)1215 void R32G32B32S::average(R32G32B32S *dst, const R32G32B32S *src1, const R32G32B32S *src2)
1216 {
1217 dst->R = gl::average(src1->R, src2->R);
1218 dst->G = gl::average(src1->G, src2->G);
1219 dst->B = gl::average(src1->B, src2->B);
1220 }
1221
readColor(gl::ColorI * dst,const R32G32B32A32S * src)1222 void R32G32B32A32S::readColor(gl::ColorI *dst, const R32G32B32A32S *src)
1223 {
1224 dst->red = src->R;
1225 dst->green = src->G;
1226 dst->blue = src->B;
1227 dst->alpha = src->A;
1228 }
1229
readColor(gl::ColorF * dst,const R32G32B32A32S * src)1230 void R32G32B32A32S::readColor(gl::ColorF *dst, const R32G32B32A32S *src)
1231 {
1232 dst->red = gl::normalizedToFloat(src->R);
1233 dst->green = gl::normalizedToFloat(src->G);
1234 dst->blue = gl::normalizedToFloat(src->B);
1235 dst->alpha = gl::normalizedToFloat(src->A);
1236 }
1237
writeColor(R32G32B32A32S * dst,const gl::ColorI * src)1238 void R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorI *src)
1239 {
1240 dst->R = static_cast<int32_t>(src->red);
1241 dst->G = static_cast<int32_t>(src->green);
1242 dst->B = static_cast<int32_t>(src->blue);
1243 dst->A = static_cast<int32_t>(src->alpha);
1244 }
1245
writeColor(R32G32B32A32S * dst,const gl::ColorF * src)1246 void R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorF *src)
1247 {
1248 dst->R = gl::floatToNormalized<int32_t>(src->red);
1249 dst->G = gl::floatToNormalized<int32_t>(src->green);
1250 dst->B = gl::floatToNormalized<int32_t>(src->blue);
1251 dst->A = gl::floatToNormalized<int32_t>(src->alpha);
1252 }
1253
average(R32G32B32A32S * dst,const R32G32B32A32S * src1,const R32G32B32A32S * src2)1254 void R32G32B32A32S::average(R32G32B32A32S *dst,
1255 const R32G32B32A32S *src1,
1256 const R32G32B32A32S *src2)
1257 {
1258 dst->R = gl::average(src1->R, src2->R);
1259 dst->G = gl::average(src1->G, src2->G);
1260 dst->B = gl::average(src1->B, src2->B);
1261 dst->A = gl::average(src1->A, src2->A);
1262 }
1263
readColor(gl::ColorF * dst,const A16B16G16R16F * src)1264 void A16B16G16R16F::readColor(gl::ColorF *dst, const A16B16G16R16F *src)
1265 {
1266 dst->red = gl::float16ToFloat32(src->R);
1267 dst->green = gl::float16ToFloat32(src->G);
1268 dst->blue = gl::float16ToFloat32(src->B);
1269 dst->alpha = gl::float16ToFloat32(src->A);
1270 }
1271
writeColor(A16B16G16R16F * dst,const gl::ColorF * src)1272 void A16B16G16R16F::writeColor(A16B16G16R16F *dst, const gl::ColorF *src)
1273 {
1274 dst->R = gl::float32ToFloat16(src->red);
1275 dst->G = gl::float32ToFloat16(src->green);
1276 dst->B = gl::float32ToFloat16(src->blue);
1277 dst->A = gl::float32ToFloat16(src->alpha);
1278 }
1279
average(A16B16G16R16F * dst,const A16B16G16R16F * src1,const A16B16G16R16F * src2)1280 void A16B16G16R16F::average(A16B16G16R16F *dst,
1281 const A16B16G16R16F *src1,
1282 const A16B16G16R16F *src2)
1283 {
1284 dst->R = gl::averageHalfFloat(src1->R, src2->R);
1285 dst->G = gl::averageHalfFloat(src1->G, src2->G);
1286 dst->B = gl::averageHalfFloat(src1->B, src2->B);
1287 dst->A = gl::averageHalfFloat(src1->A, src2->A);
1288 }
1289
readColor(gl::ColorF * dst,const R16G16B16A16F * src)1290 void R16G16B16A16F::readColor(gl::ColorF *dst, const R16G16B16A16F *src)
1291 {
1292 dst->red = gl::float16ToFloat32(src->R);
1293 dst->green = gl::float16ToFloat32(src->G);
1294 dst->blue = gl::float16ToFloat32(src->B);
1295 dst->alpha = gl::float16ToFloat32(src->A);
1296 }
1297
writeColor(R16G16B16A16F * dst,const gl::ColorF * src)1298 void R16G16B16A16F::writeColor(R16G16B16A16F *dst, const gl::ColorF *src)
1299 {
1300 dst->R = gl::float32ToFloat16(src->red);
1301 dst->G = gl::float32ToFloat16(src->green);
1302 dst->B = gl::float32ToFloat16(src->blue);
1303 dst->A = gl::float32ToFloat16(src->alpha);
1304 }
1305
average(R16G16B16A16F * dst,const R16G16B16A16F * src1,const R16G16B16A16F * src2)1306 void R16G16B16A16F::average(R16G16B16A16F *dst,
1307 const R16G16B16A16F *src1,
1308 const R16G16B16A16F *src2)
1309 {
1310 dst->R = gl::averageHalfFloat(src1->R, src2->R);
1311 dst->G = gl::averageHalfFloat(src1->G, src2->G);
1312 dst->B = gl::averageHalfFloat(src1->B, src2->B);
1313 dst->A = gl::averageHalfFloat(src1->A, src2->A);
1314 }
1315
readColor(gl::ColorF * dst,const R16F * src)1316 void R16F::readColor(gl::ColorF *dst, const R16F *src)
1317 {
1318 dst->red = gl::float16ToFloat32(src->R);
1319 dst->green = 0.0f;
1320 dst->blue = 0.0f;
1321 dst->alpha = 1.0f;
1322 }
1323
writeColor(R16F * dst,const gl::ColorF * src)1324 void R16F::writeColor(R16F *dst, const gl::ColorF *src)
1325 {
1326 dst->R = gl::float32ToFloat16(src->red);
1327 }
1328
average(R16F * dst,const R16F * src1,const R16F * src2)1329 void R16F::average(R16F *dst, const R16F *src1, const R16F *src2)
1330 {
1331 dst->R = gl::averageHalfFloat(src1->R, src2->R);
1332 }
1333
readColor(gl::ColorF * dst,const A16F * src)1334 void A16F::readColor(gl::ColorF *dst, const A16F *src)
1335 {
1336 dst->red = 0.0f;
1337 dst->green = 0.0f;
1338 dst->blue = 0.0f;
1339 dst->alpha = gl::float16ToFloat32(src->A);
1340 }
1341
writeColor(A16F * dst,const gl::ColorF * src)1342 void A16F::writeColor(A16F *dst, const gl::ColorF *src)
1343 {
1344 dst->A = gl::float32ToFloat16(src->alpha);
1345 }
1346
average(A16F * dst,const A16F * src1,const A16F * src2)1347 void A16F::average(A16F *dst, const A16F *src1, const A16F *src2)
1348 {
1349 dst->A = gl::averageHalfFloat(src1->A, src2->A);
1350 }
1351
readColor(gl::ColorF * dst,const L16F * src)1352 void L16F::readColor(gl::ColorF *dst, const L16F *src)
1353 {
1354 float lum = gl::float16ToFloat32(src->L);
1355 dst->red = lum;
1356 dst->green = lum;
1357 dst->blue = lum;
1358 dst->alpha = 1.0f;
1359 }
1360
writeColor(L16F * dst,const gl::ColorF * src)1361 void L16F::writeColor(L16F *dst, const gl::ColorF *src)
1362 {
1363 dst->L = gl::float32ToFloat16(src->red);
1364 }
1365
average(L16F * dst,const L16F * src1,const L16F * src2)1366 void L16F::average(L16F *dst, const L16F *src1, const L16F *src2)
1367 {
1368 dst->L = gl::averageHalfFloat(src1->L, src2->L);
1369 }
1370
readColor(gl::ColorF * dst,const L16A16F * src)1371 void L16A16F::readColor(gl::ColorF *dst, const L16A16F *src)
1372 {
1373 float lum = gl::float16ToFloat32(src->L);
1374 dst->red = lum;
1375 dst->green = lum;
1376 dst->blue = lum;
1377 dst->alpha = gl::float16ToFloat32(src->A);
1378 }
1379
writeColor(L16A16F * dst,const gl::ColorF * src)1380 void L16A16F::writeColor(L16A16F *dst, const gl::ColorF *src)
1381 {
1382 dst->L = gl::float32ToFloat16(src->red);
1383 dst->A = gl::float32ToFloat16(src->alpha);
1384 }
1385
average(L16A16F * dst,const L16A16F * src1,const L16A16F * src2)1386 void L16A16F::average(L16A16F *dst, const L16A16F *src1, const L16A16F *src2)
1387 {
1388 dst->L = gl::averageHalfFloat(src1->L, src2->L);
1389 dst->A = gl::averageHalfFloat(src1->A, src2->A);
1390 }
1391
readColor(gl::ColorF * dst,const R16G16F * src)1392 void R16G16F::readColor(gl::ColorF *dst, const R16G16F *src)
1393 {
1394 dst->red = gl::float16ToFloat32(src->R);
1395 dst->green = gl::float16ToFloat32(src->G);
1396 dst->blue = 0.0f;
1397 dst->alpha = 1.0f;
1398 }
1399
writeColor(R16G16F * dst,const gl::ColorF * src)1400 void R16G16F::writeColor(R16G16F *dst, const gl::ColorF *src)
1401 {
1402 dst->R = gl::float32ToFloat16(src->red);
1403 dst->G = gl::float32ToFloat16(src->green);
1404 }
1405
average(R16G16F * dst,const R16G16F * src1,const R16G16F * src2)1406 void R16G16F::average(R16G16F *dst, const R16G16F *src1, const R16G16F *src2)
1407 {
1408 dst->R = gl::averageHalfFloat(src1->R, src2->R);
1409 dst->G = gl::averageHalfFloat(src1->G, src2->G);
1410 }
1411
readColor(gl::ColorF * dst,const R16G16B16F * src)1412 void R16G16B16F::readColor(gl::ColorF *dst, const R16G16B16F *src)
1413 {
1414 dst->red = gl::float16ToFloat32(src->R);
1415 dst->green = gl::float16ToFloat32(src->G);
1416 dst->blue = gl::float16ToFloat32(src->B);
1417 dst->alpha = 1.0f;
1418 }
1419
writeColor(R16G16B16F * dst,const gl::ColorF * src)1420 void R16G16B16F::writeColor(R16G16B16F *dst, const gl::ColorF *src)
1421 {
1422 dst->R = gl::float32ToFloat16(src->red);
1423 dst->G = gl::float32ToFloat16(src->green);
1424 dst->B = gl::float32ToFloat16(src->blue);
1425 }
1426
average(R16G16B16F * dst,const R16G16B16F * src1,const R16G16B16F * src2)1427 void R16G16B16F::average(R16G16B16F *dst, const R16G16B16F *src1, const R16G16B16F *src2)
1428 {
1429 dst->R = gl::averageHalfFloat(src1->R, src2->R);
1430 dst->G = gl::averageHalfFloat(src1->G, src2->G);
1431 dst->B = gl::averageHalfFloat(src1->B, src2->B);
1432 }
1433
readColor(gl::ColorF * dst,const A32B32G32R32F * src)1434 void A32B32G32R32F::readColor(gl::ColorF *dst, const A32B32G32R32F *src)
1435 {
1436 dst->red = src->R;
1437 dst->green = src->G;
1438 dst->blue = src->B;
1439 dst->alpha = src->A;
1440 }
1441
writeColor(A32B32G32R32F * dst,const gl::ColorF * src)1442 void A32B32G32R32F::writeColor(A32B32G32R32F *dst, const gl::ColorF *src)
1443 {
1444 dst->R = src->red;
1445 dst->G = src->green;
1446 dst->B = src->blue;
1447 dst->A = src->alpha;
1448 }
1449
average(A32B32G32R32F * dst,const A32B32G32R32F * src1,const A32B32G32R32F * src2)1450 void A32B32G32R32F::average(A32B32G32R32F *dst,
1451 const A32B32G32R32F *src1,
1452 const A32B32G32R32F *src2)
1453 {
1454 dst->R = gl::average(src1->R, src2->R);
1455 dst->G = gl::average(src1->G, src2->G);
1456 dst->B = gl::average(src1->B, src2->B);
1457 dst->A = gl::average(src1->A, src2->A);
1458 }
1459
readColor(gl::ColorF * dst,const R32G32B32A32F * src)1460 void R32G32B32A32F::readColor(gl::ColorF *dst, const R32G32B32A32F *src)
1461 {
1462 dst->red = src->R;
1463 dst->green = src->G;
1464 dst->blue = src->B;
1465 dst->alpha = src->A;
1466 }
1467
writeColor(R32G32B32A32F * dst,const gl::ColorF * src)1468 void R32G32B32A32F::writeColor(R32G32B32A32F *dst, const gl::ColorF *src)
1469 {
1470 dst->R = src->red;
1471 dst->G = src->green;
1472 dst->B = src->blue;
1473 dst->A = src->alpha;
1474 }
1475
average(R32G32B32A32F * dst,const R32G32B32A32F * src1,const R32G32B32A32F * src2)1476 void R32G32B32A32F::average(R32G32B32A32F *dst,
1477 const R32G32B32A32F *src1,
1478 const R32G32B32A32F *src2)
1479 {
1480 dst->R = gl::average(src1->R, src2->R);
1481 dst->G = gl::average(src1->G, src2->G);
1482 dst->B = gl::average(src1->B, src2->B);
1483 dst->A = gl::average(src1->A, src2->A);
1484 }
1485
readColor(gl::ColorF * dst,const R32F * src)1486 void R32F::readColor(gl::ColorF *dst, const R32F *src)
1487 {
1488 dst->red = src->R;
1489 dst->green = 0.0f;
1490 dst->blue = 0.0f;
1491 dst->alpha = 1.0f;
1492 }
1493
writeColor(R32F * dst,const gl::ColorF * src)1494 void R32F::writeColor(R32F *dst, const gl::ColorF *src)
1495 {
1496 dst->R = src->red;
1497 }
1498
average(R32F * dst,const R32F * src1,const R32F * src2)1499 void R32F::average(R32F *dst, const R32F *src1, const R32F *src2)
1500 {
1501 dst->R = gl::average(src1->R, src2->R);
1502 }
1503
readColor(gl::ColorF * dst,const A32F * src)1504 void A32F::readColor(gl::ColorF *dst, const A32F *src)
1505 {
1506 dst->red = 0.0f;
1507 dst->green = 0.0f;
1508 dst->blue = 0.0f;
1509 dst->alpha = src->A;
1510 }
1511
writeColor(A32F * dst,const gl::ColorF * src)1512 void A32F::writeColor(A32F *dst, const gl::ColorF *src)
1513 {
1514 dst->A = src->alpha;
1515 }
1516
average(A32F * dst,const A32F * src1,const A32F * src2)1517 void A32F::average(A32F *dst, const A32F *src1, const A32F *src2)
1518 {
1519 dst->A = gl::average(src1->A, src2->A);
1520 }
1521
readColor(gl::ColorF * dst,const L32F * src)1522 void L32F::readColor(gl::ColorF *dst, const L32F *src)
1523 {
1524 dst->red = src->L;
1525 dst->green = src->L;
1526 dst->blue = src->L;
1527 dst->alpha = 1.0f;
1528 }
1529
writeColor(L32F * dst,const gl::ColorF * src)1530 void L32F::writeColor(L32F *dst, const gl::ColorF *src)
1531 {
1532 dst->L = src->red;
1533 }
1534
average(L32F * dst,const L32F * src1,const L32F * src2)1535 void L32F::average(L32F *dst, const L32F *src1, const L32F *src2)
1536 {
1537 dst->L = gl::average(src1->L, src2->L);
1538 }
1539
readColor(gl::ColorF * dst,const L32A32F * src)1540 void L32A32F::readColor(gl::ColorF *dst, const L32A32F *src)
1541 {
1542 dst->red = src->L;
1543 dst->green = src->L;
1544 dst->blue = src->L;
1545 dst->alpha = src->A;
1546 }
1547
writeColor(L32A32F * dst,const gl::ColorF * src)1548 void L32A32F::writeColor(L32A32F *dst, const gl::ColorF *src)
1549 {
1550 dst->L = src->red;
1551 dst->A = src->alpha;
1552 }
1553
average(L32A32F * dst,const L32A32F * src1,const L32A32F * src2)1554 void L32A32F::average(L32A32F *dst, const L32A32F *src1, const L32A32F *src2)
1555 {
1556 dst->L = gl::average(src1->L, src2->L);
1557 dst->A = gl::average(src1->A, src2->A);
1558 }
1559
readColor(gl::ColorF * dst,const R32G32F * src)1560 void R32G32F::readColor(gl::ColorF *dst, const R32G32F *src)
1561 {
1562 dst->red = src->R;
1563 dst->green = src->G;
1564 dst->blue = 0.0f;
1565 dst->alpha = 1.0f;
1566 }
1567
writeColor(R32G32F * dst,const gl::ColorF * src)1568 void R32G32F::writeColor(R32G32F *dst, const gl::ColorF *src)
1569 {
1570 dst->R = src->red;
1571 dst->G = src->green;
1572 }
1573
average(R32G32F * dst,const R32G32F * src1,const R32G32F * src2)1574 void R32G32F::average(R32G32F *dst, const R32G32F *src1, const R32G32F *src2)
1575 {
1576 dst->R = gl::average(src1->R, src2->R);
1577 dst->G = gl::average(src1->G, src2->G);
1578 }
1579
readColor(gl::ColorF * dst,const R32G32B32F * src)1580 void R32G32B32F::readColor(gl::ColorF *dst, const R32G32B32F *src)
1581 {
1582 dst->red = src->R;
1583 dst->green = src->G;
1584 dst->blue = src->B;
1585 dst->alpha = 1.0f;
1586 }
1587
writeColor(R32G32B32F * dst,const gl::ColorF * src)1588 void R32G32B32F::writeColor(R32G32B32F *dst, const gl::ColorF *src)
1589 {
1590 dst->R = src->red;
1591 dst->G = src->green;
1592 dst->B = src->blue;
1593 }
1594
average(R32G32B32F * dst,const R32G32B32F * src1,const R32G32B32F * src2)1595 void R32G32B32F::average(R32G32B32F *dst, const R32G32B32F *src1, const R32G32B32F *src2)
1596 {
1597 dst->R = gl::average(src1->R, src2->R);
1598 dst->G = gl::average(src1->G, src2->G);
1599 dst->B = gl::average(src1->B, src2->B);
1600 }
1601
readColor(gl::ColorUI * dst,const R10G10B10A2 * src)1602 void R10G10B10A2::readColor(gl::ColorUI *dst, const R10G10B10A2 *src)
1603 {
1604 dst->red = src->R;
1605 dst->green = src->G;
1606 dst->blue = src->B;
1607 dst->alpha = src->A;
1608 }
1609
readColor(gl::ColorF * dst,const R10G10B10A2 * src)1610 void R10G10B10A2::readColor(gl::ColorF *dst, const R10G10B10A2 *src)
1611 {
1612 dst->red = gl::normalizedToFloat<10>(src->R);
1613 dst->green = gl::normalizedToFloat<10>(src->G);
1614 dst->blue = gl::normalizedToFloat<10>(src->B);
1615 dst->alpha = gl::normalizedToFloat<2>(src->A);
1616 }
1617
writeColor(R10G10B10A2 * dst,const gl::ColorUI * src)1618 void R10G10B10A2::writeColor(R10G10B10A2 *dst, const gl::ColorUI *src)
1619 {
1620 dst->R = static_cast<uint32_t>(src->red);
1621 dst->G = static_cast<uint32_t>(src->green);
1622 dst->B = static_cast<uint32_t>(src->blue);
1623 dst->A = static_cast<uint32_t>(src->alpha);
1624 }
1625
writeColor(R10G10B10A2 * dst,const gl::ColorF * src)1626 void R10G10B10A2::writeColor(R10G10B10A2 *dst, const gl::ColorF *src)
1627 {
1628 dst->R = gl::floatToNormalized<10, uint32_t>(src->red);
1629 dst->G = gl::floatToNormalized<10, uint32_t>(src->green);
1630 dst->B = gl::floatToNormalized<10, uint32_t>(src->blue);
1631 dst->A = gl::floatToNormalized<2, uint32_t>(src->alpha);
1632 }
1633
average(R10G10B10A2 * dst,const R10G10B10A2 * src1,const R10G10B10A2 * src2)1634 void R10G10B10A2::average(R10G10B10A2 *dst, const R10G10B10A2 *src1, const R10G10B10A2 *src2)
1635 {
1636 dst->R = gl::average(src1->R, src2->R);
1637 dst->G = gl::average(src1->G, src2->G);
1638 dst->B = gl::average(src1->B, src2->B);
1639 dst->A = gl::average(src1->A, src2->A);
1640 }
1641
readColor(gl::ColorF * dst,const R9G9B9E5 * src)1642 void R9G9B9E5::readColor(gl::ColorF *dst, const R9G9B9E5 *src)
1643 {
1644 gl::convert999E5toRGBFloats(gl::bitCast<uint32_t>(*src), &dst->red, &dst->green, &dst->blue);
1645 dst->alpha = 1.0f;
1646 }
1647
writeColor(R9G9B9E5 * dst,const gl::ColorF * src)1648 void R9G9B9E5::writeColor(R9G9B9E5 *dst, const gl::ColorF *src)
1649 {
1650 *reinterpret_cast<uint32_t *>(dst) =
1651 gl::convertRGBFloatsTo999E5(src->red, src->green, src->blue);
1652 }
1653
average(R9G9B9E5 * dst,const R9G9B9E5 * src1,const R9G9B9E5 * src2)1654 void R9G9B9E5::average(R9G9B9E5 *dst, const R9G9B9E5 *src1, const R9G9B9E5 *src2)
1655 {
1656 float r1, g1, b1;
1657 gl::convert999E5toRGBFloats(*reinterpret_cast<const uint32_t *>(src1), &r1, &g1, &b1);
1658
1659 float r2, g2, b2;
1660 gl::convert999E5toRGBFloats(*reinterpret_cast<const uint32_t *>(src2), &r2, &g2, &b2);
1661
1662 *reinterpret_cast<uint32_t *>(dst) =
1663 gl::convertRGBFloatsTo999E5(gl::average(r1, r2), gl::average(g1, g2), gl::average(b1, b2));
1664 }
1665
readColor(gl::ColorF * dst,const R11G11B10F * src)1666 void R11G11B10F::readColor(gl::ColorF *dst, const R11G11B10F *src)
1667 {
1668 dst->red = gl::float11ToFloat32(src->R);
1669 dst->green = gl::float11ToFloat32(src->G);
1670 dst->blue = gl::float10ToFloat32(src->B);
1671 dst->alpha = 1.0f;
1672 }
1673
writeColor(R11G11B10F * dst,const gl::ColorF * src)1674 void R11G11B10F::writeColor(R11G11B10F *dst, const gl::ColorF *src)
1675 {
1676 dst->R = gl::float32ToFloat11(src->red);
1677 dst->G = gl::float32ToFloat11(src->green);
1678 dst->B = gl::float32ToFloat10(src->blue);
1679 }
1680
average(R11G11B10F * dst,const R11G11B10F * src1,const R11G11B10F * src2)1681 void R11G11B10F::average(R11G11B10F *dst, const R11G11B10F *src1, const R11G11B10F *src2)
1682 {
1683 dst->R = gl::averageFloat11(src1->R, src2->R);
1684 dst->G = gl::averageFloat11(src1->G, src2->G);
1685 dst->B = gl::averageFloat10(src1->B, src2->B);
1686 }
1687
1688 } // namespace angle
1689