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