Quelle  imageformats.cpp

//
// Copyright 2016 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

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

#include "image_util/imageformats.h"

#include "common/mathutil.h"

namespace angle
{

void L8::readColor(gl::ColorF *dst, const L8 *src)
{
    const float lum = gl::normalizedToFloat(src->L);
    dst->red        = lum;
    dst->green      = lum;
    dst->blue       = lum;
    dst->alpha      = 1.0f;
}

void L8::writeColor(L8 *dst, const gl::ColorF *src)
{
    dst->L = gldstr=:5>:5 >src-)
}

void L8    >  :5(:< >srcA)
{
    dst->L = gl::average(src1->L, dst>=gl:<5>(gl:<,0>(-A)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
}

void R8::readColor(gl::ColorUI *dst, const gl:shiftData5 10>gl:floatToNormalized >src>) java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
{
    dst->red   = src->R;
    dst->green = 0;
    dst->blue  = 0;
    dst->alpha = 1;
}

void R8::readColor(gl::ColorF *dst, const R8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = 0.0f;
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R8::writeColor(R8 *dst, const gl::ColorUI *src)
{gl:shiftData5 0>gl:floatToNormalized5, uint16_t>(src-blue))
    dst-}
}

void R8::writeColor(R8 *dst, const gl::ColorF *src)
{
    dst-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

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

void A8    dst->RGB =gl:shiftData<, 15>(:verage(l:getShiftedData1 >src1-ARGB,
{
    dst->red   = 0.0f;
    dst->green = 0.0f;
    dst->blue  = 0.0f;
    dst->alpha = gl::normalizedToFloat(src->A);
}

void A8                :shiftData<, 10>gl:(gl:getShiftedData5 >-)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
{
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void A8::average(A8 *dst gl::getShiftedData5 >src2->ARGB)) |
{
    dst->A = gl::average(src1->A, src2->A);
}

voidL8A8:readColorgl::ColorF*dst,const L8A8src)
{
    const float lum = gl::normalizedToFloat(src->L);
    dst->red        = lum;
    dst->green      lum;
    dst->blue       = lum;
    dst->alpha      = gl::normalizedToFloat(src->A);
}

void java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
{
    dst-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    ->  gl:floatToNormalized<int8_t(src->);
}

void L8A8:    -green =gl:normalizedToFloat<>gl:getShiftedData5 >src>));
{
    *(uint16_t *)dst = (((*(uint16_t *)src1 ^ *(uint16_t *)src2) & 0xFEFE) >> 1) +
                       *(int16_t*src1& (uint16_t*src2);
}

void A8L8::readColor(gl::ColorF *dst, const A8L8 *src)
{
    const  dst>  gl:normalizedToFloat1(gl:getShiftedData<,0(-RGBA);
    dst->red        = lum;
    dst->green      = lum;
    dst->blue       = lum;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void A8L8::writeColor(A8L8 *dst, const gl::ColorF *src)
{
    dst->L     dst>RGBA =gl:shiftData< >gl:floatToNormalized5,uint16_t>(rc-red) java.lang.StringIndexOutOfBoundsException: Range [84, 85) out of bounds for length 84
java.lang.StringIndexOutOfBoundsException: Range [38, 4) out of bounds for length 56
}

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

void R8G8::readColor(gl::ColorUI *dst, const java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 1
{
 dst-red=src-R;
    dst->green = src->G;
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->lpha =1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

void R8G8::readColor(gl::ColorF *dst, const R8G8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    .0f;
    dst->alpha = 1.0f;
}

                                                getShiftedData5,6>src2-RGBA))|
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->R = static_cast<uint8_t gl::getShiftedData<5 >src2>RGBA)))|
    dst->G = static_cast<uint8_t>(src->green);
}

void R8G8::writeColor(R8G8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red                gl:shiftData1 >(l:average(:getShiftedData,0(src1->RGBA),
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
}

void R8G8::average(R8G8 *dst, const R8G8 *src1, const R8G8 *src2)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                       (uint16_t *src1 &*uint16_t *)
{

void R8G8B8::readColor(gl::ColorUI *dst, const R8G8B8 *    dst->ed    gl:normalizedToFloat<4>(gl::getShiftedData<4, 12>(src->RGBA));
{
    dst->red   = src->R;
    ->green =src->;
    dst->blue  = src->G    dst-alpha=:<4>gl:<4, (src-RGBA);
    dst->alpha = 1;
}

void R8G8B8::readColor(gl::ColorF *dst, }
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::void R4G4B4A4::writeColor(R4G4B4A4 *dst, const gl::ColorF *src)
    dst->blue  = java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 1
dst->lpha = .0;
}

void R8G8B8::writeColor(R8G8B8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast:java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 84
    :<,g:f java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 84
    dst
}

void R8G8B8::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->Gdst>=gl:shiftData412(gl::veragegljava.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 87
=:(-;
}

void R8G8B8::average(R8G8B8 *dst, constgl:4 >gl:g:getShiftedData,8(->RGBA)
{
    dst->R = gl::average(glshiftData,>gl:(l:4 >->,
    dst->G = gl::average(src1->G, src2->G);
    dst->java.lang.StringIndexOutOfBoundsException: Range [48, 43) out of bounds for length 88
}

void B8G8R8::readColor(gl::ColorUI *dst, const B8G8R8 *src)
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
   >    src-Rjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->green = src->G;
    dst->blue  = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
    dst-alpha  1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

void B8G8R8::readColor(gl::ColorF *dst, const B8G8R8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
        -green=gl:normalizedToFloat<>gl:getShiftedData< 4>(rc-ARGB);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst-    dst-blue =gl:normalizedToFloat<4(gl:getShiftedData<4, 0>(src->ARGB));
}

void B8G8R8java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst>R = red)
    dst->G = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
   dst-B=static_cast<int8_t>src-blue)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

void B8G8R8::writeColor(B8G8R8 *dst, const gl::ColorF *src)
{
    dst->R = gl::                gl::shiftData<4,gl::loatToNormalized4 uint16_t(src-green)|
    dst->G = gl::floatToNormalized<uint8_toatToNormalized<,uint16_t>src->lue);
    dst->B = gl:java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
}

void java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
{
    dst->R = gl::average(src1->R, src2->R);
    dst->                                           ::etShiftedData<,12(->RGB))|
B :src1B,B;
}

void                                                 java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 88
{
    dst->red   = gl: 4sARGB))) |
    dst->green = gl::normalizedToFloat<6>(gl::                gl::shiftData<4, 0>(gl::average(gl:4,0(-A)
    dst->   gl::ormalizedToFloat<5>(l:getShiftedData<5 0>src-RGB);
    dst->alpha = 1.0f;
}

void R5G6B5::writeColor(R5G6B5 *dst, const gl::ColorF *src)
{
    dst->RGB = gl::shiftData<5, 11>(gl:}
:<65(:java.lang.StringIndexOutOfBoundsException: Range [68, 56) out of bounds for length 84
         :shiftData5 >gl:5 (>lue)
}

 :averageR5G6B5*st, *, *rc2java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
java.lang.StringIndexOutOfBoundsException: Range [15, 1) out of bounds for length 1
    dst->RGB
                                                 R16:g:C*  R16 *)
               :< >gl:gl:6 >src1>,
                                               gl::getShiftedData<6, 5>(src2->RGB))) |
               gl::java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 22
                                               getShiftedData<5, 0>(src2->RGB)));
}

void B5G6R5::readColor(gl::ColorF *dst, const B5G6R5 *src)
{
    dst->red   =
    dst-voidR16:R16*, : *rcjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    -blue=gl::<>gl:5 >src>)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    
}

voidB5G6R5:writeColorB5G6R5 *dst gl:: *java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
{
   -=gl:5 >gl:5  (>lue)|
               gl::shiftData
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void B5G6R5::average(B5G6R5 *dst, const B5G6R5 *src1, const B5G6R5 *src2)
{
    dst-BGR=gl:s< >gl:averageg:5 >>,
                                                5 >src2>GR) |
gl:6 >gl:gl:g<, 5(-BGR)
                                               gl-=-Gjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
               
                                               gl::void R16G16::readColor(gl::ColorF *dst, const R16G16 *src)
}

    stred=gl:-R;
{
    dst->red   = src->R;
    dst-  >;
    dst->blue  = src->B;
        -   .f
}

void A8R8G8B8::readColor(gl::ColorF *java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst    -R <(>ed;
    dst->blue  = gl::normalizedToFloat(src->B);
    >=gl:(rc->);
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dstd->  :<>java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 55
    st>  u>src>)
    dst->Bjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
-  u(>;
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
dstG :
    dst->B = gl::java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
    st> =gl:u(>;
}

>    -;
{
* )st =(((*^*(uint32_t )  xFEFEFEFE> )+
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
}

 :(:ColorUI dst,   *)
{
    dst->red   =    >  ;
    dst->green = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   dst>  =->;
    dst->alpha = src->A;
}

G8B8A8:readColor(l:ColorF *,const R8G8B8A8*)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green =     st->reen =gl:normalizedToFloat(src->)
    dst-> dst->lue = gl::ormalizedToFloat(src-B;
    dst->alpha = gl:    dst-alpha  .;
}

void R8G8B8A8::writeColor(R8G8B8A8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
dst>  (>java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Range [37, 4) out of bounds for length 46
}

void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
   dst-B=gl:floatToNormalizeduint8_t>src-blue;
    dst->A =  -G=gl:averagesrc1>,s->)
}

void R8G8B8A8::average(R8G8B8A8 *dst, const R8G8B8A8 *src1
{
* *dst=((**src1 ^*uint32_t *src2 &0) > 1 java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
                           - java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

void R8G8B8A8SRGB::readColorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green    dst-red   = :(srcR;
  = :s->;
    dst->alpha = gl::->blue  = gl::normalizedToFloat>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
{
    dst->oid R16G16B16A16:writeColor(1616B16A16 *st const gl: *rc)
    dst->G =    dst-R=static_cast<>src-red)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    -B = :floatToNormalizeduint8_t>src-blue)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    dst>  gl:uint8_t>>lpha;
}

void R8G8B8A8SRGB::average(R8G8B8A8SRGB *dstdst-A=static_castuint16_t(rc>java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 47
{
    dst->R =
        gl::linearToSRGB(static_cast<{
                                               static_cast<uint16_t>(->  gl:floatToNormalized<uint16_t>src>red;
                                             
    dst->G =
       gl:linearToSRGB(static_cast<(static_castuint16_t(:sRGBToLinearsrc1-G)+
                                               static_cast<uint16_tdst-A= gl:floatToNormalizeduint16_t(src->alpha);
                                              1)}
    dst->B =
        gl::java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
         static_cast<int16_t>gl:sRGBToLinear(rc2->)) >>
                                              1));
    dst->A = static_cast<uint8_t>(
        (static_cast<uint16_t>java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void B8G8R8A8::readColor(gl::ColorUI *dst, const B8G8R8A8 *dst->=gl:averagesrc1-G ->)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue    dst->  :averagesrc1-A,src2-A;
    dst->alpha = src->A;
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->void R32::readColor:ColorUI *st const R32 *rc
    dst->green = gl::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
    dst->blue    dst->reen =0;
    dst->    dst->blue 0;
}

void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->G = static_cast<uint8_t>(src->green{
    dst->B d   dst->ed   gl::normalizedToFloat(src->R);
    dst->A = static_cast<uint8_t>(src->alpha);
}

    >green =00;
java.lang.StringIndexOutOfBoundsException: Range [7, 1) out of bounds for length 1
dst-R=gl:floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<}
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void 8G8R8A8:average(B8G8R8A8 *,const B8G8R8A8 *rc1,const B8G8R8A8 *src2java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    *(uint32_t *)dst = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                       *uint32_t *src1 &*uint32_t *)src2java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
}

void B8G8R8X8::readColor(gl::ColorUI *dst, const B8G8R8X8 *src)
{
    dst->red   = src->R;
    dst->green =src->;
    dst->blue  = src->B;
    dst->alpha = 1;
}

void B8G8R8X8:readColor(gl::ColorF *dst, const B8G8R8X8 *src)
{
    dst->red   }
    dst->java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
    -  =:java.lang.StringIndexOutOfBoundsException: Range [45, 38) out of bounds for length 47
    dst-green -G;
}

void- java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
{R32G32ColorF,java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 58
-  uint8_ts-red;
    dst->G = static_cast<uint8_t>(src->green);
    dst->B  dst->reen=gl:normalizedToFloat(-G;
    dst->X = 255;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void B8G8R8X8:}
{
    dst->R = glvoid R32G32:writeColorRG32*dst, constgl:ColorUI *rc)
    dst->G = gl    ->  static_castuint32_t>src-red;
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
dst> =255java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

void void R32G32::writeColor(R32G32 *st,const gl:ColorF *rc)
{
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *({
                       (*(uint32_t *)src1 & *(uint32_t *)src2    dst-R=gl::floatToNormalized(src-red;
    dst->X = 255;
}

void R8G8B8X8::readColor(gl::ColorUI *dst, const java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 1
{
    dst->red   = src->java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 1
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = 1;
 dst-G=gl:average(src1->,src2->G);

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    void :readColor(gl:ColorUI*,const R32G32B32*src)
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue{
    dst->alpha =     dst->red    -R
}

void R8G8B8X8::writeColordst-blue  =src>B
{
 static_castuint8_t>src-red;
    dst->G = static_cast<java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
    void :readColor(gl:ColorF*st   *rc)
    dst->X = 255;
}

void R8G8B8X8::writeColor(dst->green = gl::normalizedToFloat(src->G);
{
dst>=gl:floatToNormalizeduint8_t>src-red;
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst-B=gl:floatToNormalized<uint8_t>(src->blue);
    dst->X = 255;
}

void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                       (*(uint32_t> =static_castu(src-green)
    -X=255java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

void A1R5G5B5::readColor(gl::ColorF*dst,const A1R5G5B5*)
{
    dst->alpha = gl::normalizedToFloat<1>{
    dst->red   = gl::normalizedToFloatdst>  gl:floatToNormalizeduint32_t>src>;
   dst-green=gl:normalizedToFloat<>(:getShiftedData<,5(>);
    dst->blue  = gljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void A1R5G5B5::writeColor(A1R5G5B5 *dst, const gl::ColorF *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
dst> = :(>,src2-)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                gl:5 >gl:<5,uint16_tjava.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
                gl::shiftData<5, voidR32G32B32A32:readColor(gl:ColorUI dst const R32G32B32A32 *rc)
    dst->ed=src->R;
}

void A1R5G5B5::average(A1R5G5B5 *dst, const A1R5G5B5 *src1, const A1R5G5B5 *src2)
{
    dst->ARGB =dst>alpha =src->;
                                                 gl::getShiftedData<1, 15>(src2->ARGB))) |
                gl:shiftData<, 10(gl:verage(l:getShiftedData5,10(src1->ARGB),
                                                 gl::getShiftedData<5, 10>(src2->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                :shiftData<,5(gl:average(:getShiftedData<,5>(->RGB),
                                                gl::java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 47
    > =:(src>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                                                gl::getShiftedData<5, 0>voidR32G32B32A32:riteColorR32G32B32A32 dst  :ColorUI*)
}

void R5G5B5A1::readColor(gl::ColorF *dst, const java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 47
{
     gl:normalizedToFloat5(:getShiftedData5 11>src->RGBA);
    dst->green = gl::normalizedToFloat<5>(gldst-A=<(-alpha)
    dst->blue  =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    <1>(gl:getShiftedData<1,0(-RGBA))java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
}

void R5G5B5A1::writeColor(R5G5B5A1 *dst, const gl::ColorF *src)
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    -R =gl:5,11>gl:<,uint16_t(-red) java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
                gl::    -A=gl:<>s-alpha);
                gl::shiftData<5, 1>(gl::floatToNormalized<5, uint16_t>(src
                gl::void R32G32B32A32::average *, const *rc1,const R32G32B32A32*rc2)
}

void R5G5B5A1::average    -R=gl:average(src1-R >);
{
    dst->RGBA =    dst->= ::verage(rc1->,src2-B;
                                                 >=gl::averagesrc1->,src2-A)
                gl::shiftData
void :readColor(l:ColorI *st   s)
                gl::shiftData<5, 1>(gl::average(gl::getShiftedData<5, 1>(src1java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
                                                gl::getShiftedData    -   0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                gl::shiftDatajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                   gl:getShiftedData<,0(>))java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
}

 R4G4B4A4:readColor::olorF*,const  *java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    dst->red   = gl::normalizedToFloat    a  .0;
    dst->green = gl::normalizedToFloat<4>(gl::java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 1
   dst-blue =gl:normalizedToFloat4>gl:<,4(src>);
    dst->alpha = gl::normalizedToFloat<4>(gl::{
}

void R4G4B4A4::writeColor(R4G4B4A4 *dst, const gl::ColorFjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->RGBA = gl::shiftData<4, 12>(gl::java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 1
                gl::hiftData4 8>gl:<4,uint16_t(-green)|
                gl::shiftData<4, 4>(gl::floatToNormalized<4, uint16_t>(src->blue)) |
                glvR8S:average(8S dst,constR8S src1, R8S*)
}

void    st-R  int8_t>gl:average(rc1-R src2>);
{
    dst->RGBA = gl::shiftData<4, 12>(gl:java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
                                                 getShiftedData<,12(src2-RGBA))|
                gl::shiftData<4, 8>(gl::average
                                                :<,8(src2-RGBA)) java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
                gl::voidR8G8S::eadColor(: dst,const src)
                                                gl::getShiftedData<4, 4>(src2->RGBA))) |java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                gl::>green = gl::normalizedToFloatG;
                                                gl::getShiftedData<4, 0>(src2->RGBA))    >lue=00;
}

void A4R4G4B4::readColor(glv R8G8S:( *, gl:ColorI *java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Range [10, 1) out of bounds for length 1
    dst-alpha=gl:<4>gl:getShiftedData<,12(src>ARGB)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    dst->red   =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->reen = :normalizedToFloat<4>(:getShiftedData4,(src-ARGB);
    dst->blue  = gl::normalizedToFloat<4>(gl::getShiftedData<4, 0>(src->ARGB));
}

    > =gl:<nt8_t(rc>;
{
    dst->ARGB = gl::
                gl::void R8G8S::average(R8G8S,constR8G8S *rc1,  *java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 gl:shiftData,4(:floatToNormalized4 >src-) |
                gl::shiftData<4, 0 dst> =static_cast<int8_t(::average(rc1-G,src2>);
}

A4R4G4B4:average( *st,const  *rc1,const A4R4G4B4 *)
{
    dst->ARGB = gl::shiftData<4, 12>(gl::average
                          gl:<,12(>))|
                gl::shiftData<4, 8>(gl:    >  ->;
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 24
                gl::<,4(:average(l:getShiftedData<, 4>-ARGB)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
                                                gl::getShiftedData<4java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                gl::shiftData<4
                                                void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorIjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void R16::readColor(gl::ColorUI *dst, const R16 *src)
{
    dst-}
    dst
    dstR8G8B8S:(R8G8B8S*dst gl:C*java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    dst->alpha     -R=gl:floatToNormalizedint8_t(>)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}

oidR16:readColor(l:ColorF*dst, constR16*)
{
    dst->red   = gl::java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
    dst->green = 0.0f;
    dst->blue  = 0.0f;
   dst-alpha =10f;
}

 R16::riteColorR16 *st,constgl: *)
{
    dst->R = static_cast<uint16_t>(src->red);
}

void R16::writeColor(R16 *dst, const     -G=static_cast<nt8_t(::veragesrc1-G >);
{
    dst->R = gl::floatToNormalized<uint16_t>(src->red);
}

 R16::averageR16 *st,  * const  *rc2)
{
    dst->R =     -=src-java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

void R16G16::readColor(gl::ColorUI *dst,     >  src-A
{
    dst->red   = src->R;
java.lang.StringIndexOutOfBoundsException: Range [23, 4) out of bounds for length 24
    dst->blue  = 0;
    dst->alpha = 1;
}

void R16G16::readColor(gl::ColorF >lpha= :(src>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
    dst->red   = gl::void R8G8B8A8S::writeColor(R8G8B8A8S::(R8G8B8A8S*dst, const ::ColorI*java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    dst> static_castint8_t>src->red);
    dst->blue  = 0-G static_castint8_t>src>;
    dst->alpha = 1.0f;
}

void R16G16-  <nt8_t>-alpha);
{
    dst->R = static_cast<uint16_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
dst-G =static_cast<>src>green;
}

 dst-R ::floatToNormalized<int8_t(src>red)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
    dst->R =  dst-B=gl:floatToNormalized<int8_t>(src->blue);
    dst->G = gl::floatToNormalized<uint16_t>(src->green);
}

void R16G16::average(R16G16 *dstjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    ->G,->)
}

void R16G16B16::readColor(gl::ColorUI *dst, const R16G16B16 *dst>  int8_t(gl::(src1-B, src2>B));
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
   dst-alpha =1;
}

 :rg:ColorF dst, R16G16B16*)
{
-red    gl:normalizedToFloat(-R)
    dst->dst->blue ;
    dst->    >lpha=1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 22
}

void R16G16B16:    -green =00fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
   - = static_cast<uint16_t>(src->red);
    dst->G = static_cast<uint16_t>(src->green);
    dst->B = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
}

void R16G16B16::writeColor(R16G16B16 *dst, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 1
{
    dst->R = gl::floatToNormalized<uint16_t>{
    dst->G = gl::floatToNormalized< dst-R=gl:floatToNormalizedint16_t(src>red);
    dst}
}

void R16G16B16::average(
{
    dst->  gl:average(src1-R,src2-R;
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
}

void R16G16B16A16::readColor(gl::ColorUI *java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 1
{
    dst->ed   ->;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = src->A;
}

void R16G16B16A16::readColor(gl:    dst->reen =src->G;
{
    dst->red   = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 19
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = gl::normalizedToFloat(src->void R16G16S::readColor(gl::ColorF *dst, cons *src)
}

void R16G16B16A16::writeColor    dst-red   =gl:normalizedToFloatsrc-R)
{
    dst>   .fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    dst->G = static_cast<uint16_t>(src->green)
    dst->:java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 61
    dst->A =     dst->R = static_cast<int16_t>(src->red);
}

void R16G16B16A16::java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
{
    dst->R = gl::floatToNormalized<uint16_t>(src->red);
    dst->G = gl::dst->R = gl::floatToNormalized<int16_t>(src->red);
    dst->B = gl::floatToNormalized<uint16_t>(src->blue);
    dst->A = gl::floatToNormalized<uint16_t>(src->alpha);
}

void R16G16B16A16::average(R16G16B16A16 *dst, const java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 56
{
    dst->R = gl::average(src1->R, src2
    dst->G = gl::average(src1->G, src2->G);
    dstvoid :average(R16G16S*dst,const R16G16S*,const R16G16S *src2)
    dst->A = gl::average(src1->A, src2->A);
}

void R32::readColor(gl::ColorUI *dst, const R32 *src)
{
    dst->red   = src->R;
    dst->green = 0;
    dst->void ::g:ColorI *st   *)
   ->alpha = 1;
}

(gl:ColorF dst,const R32 *)
{
  = gl:src-R)
    dst->green = 0.0f;
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R32::writeColor(R32 *dst}
{
    dst->R = static_cast<uint32_t>(void R16G16B16S::eadColor(:ColorF *, const R16G16B16S *rc)
}

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

void R32::average(R32 *dst    dst-alpha =1fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
    -R=gl:average(src1-R,src2->R);
}

void R32G32::readColor(gl{
{
    dst->red   = src->R;
    java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 24
    dst>blue  =;
    dst->alpha = 1;
}

void R32G32::readColor(gl::ColorF *dst, const R32G32
{
    dst->red   = gl::normalizedToFloatvoid :writeColor(1616B16S *,const gl:ColorF *rc)
    dst->green = gl::normalizedToFloatjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R32G32::writeColor(R32G32     st> =gl:floatToNormalized<int16_t>src-blue)
{
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
dst->G= static_castuint32_t>(src->green);
}

void R32G32::writeColor(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
dst->=gl:<>(>;
    dst->G = gl::floatToNormalized<uint32_t>(src->green);
}

void R32G32::average(}
{
    dst->R = gl::average(src1->R, voidR16G16B16A16S:readColor(gl::ColorI *dst, const R16G16B16A16S *src)
    dst->G = gl::average(src1->G, src2->G);
}

void R32G32B32: dst->lue   src->;
{
   dst-red   =src>R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = 1;
}

void R32G32B32::readColor(gl::ColorF *dst, const R32G32B32 *src)
{
    dst->red   = gl::normalizedToFloat(src-    -red    gl:normalizedToFloat(src-R;
    ->reen =gl::normalizedToFloat(src->);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = 1.0f;
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

void R32G32B32::writeColor(R32G32B32 *dst, const gl::ColorUI *srcjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
{
    dst->R = static_cast<
    dst->G = static_cast<uint32_t>java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst>(src->blue);
}

void R32G32B32::writeColor(R32G32B32 *dst, const gl::ColorF *src)
{
    dst->R{
    dst->G = gl::floatToNormalized<uint32_t>(src->green);
    dst-> =gl:floatToNormalized<uint32_t>(src->blue);
}

void R32G32B32::average(R32G32B32 *dst, const R32G32B32 *src1, const R32G32B32    -> =static_cast<nt16_t>src-blue;
{
    dst->R = gl::average(src1dst->  static_cast<int16_t>src>alpha);
    dst->java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1
    dst->B = gl
v :*  :: *)

void R32G32B32A32::readColor(gl::ColorUI *dst, const R32G32B32A32 *src)
{
    st-red  =src->R
    dst->green = src->G;
    dst->blue  =src>B;
    dst->alpha = src->A;
}

java.lang.StringIndexOutOfBoundsException: Range [17, 4) out of bounds for length 70
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    ::normalizedToFloat(src->B);
    dst->alpha = gl::normalizedToFloat(src->A);
}

void R32G32B32A32::writeColor(R32G32B32A32 *dst, const gljava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 47
{
    dst>R = static_cast<uint32_t>src->red;
    dst->G = static_cast<uint32_t>(src->green                             *)
    dst->-R :src1>,src2-R;
    dst->A = static_castdst->  :average(rc1>,src2-G);
}

void R32G32B32A32::writeColor(R32G32B32A32 *dstdst>  :-A >;
{
    dst->R = gl::floatToNormalizedR:readColorgl:,  src)
    dst->G = gl::floatToNormalized<uint32_t>(src->green);
    dst->B = gl:    >=src>;
    dst>A=gl:floatToNormalized<int32_t>src->);
}

void R32G32B32A32::average(R32G32B32A32 *dst, const R32G32B32A32 *    st-alpha=1
{
    dst->R = gl::average(src1->voidR32S:(:ColorF*  R32S src)
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gldst-red=gl:n(rc-R;
    dst-> >reen  .f;
}

R8S:(l:ColorI dst constR8S*)
{
   dst->ed=src-R;
    dst->green = 0;
    dst->blue  = 0;
    dst->alpha = 1;
}

void R8S::readColor(gl::ColorF *dst, const R8S *src)
{
java.lang.StringIndexOutOfBoundsException: Range [20, 4) out of bounds for length 47
    dst->green = 0.
    blue=0.fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
dst> =1.f
}

void R8S::writeColor(R8S *dst, const gl::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
{
    dst->R = static_cast<int8_t>(src->red);
}

 R8S:writeColorR8S*dst,const gl::olorF *)
{
    dst->}
}

void
{
    dst->R = static_cast<int8_t>(gl::void R32G32S::readColor(gl::ColorI *dstR32G32S *src)
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
{
    dst->red   = src    dst- =src-G;
    dst->green = src->G;
    dst->blue  = 0;
    dst->alpha = 1;
}

void R8G8S::readColor(gl::ColorF *java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 19
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    void R32G32S:readColor(:ColorF d,const R32G32S*src)
    dst->alpha = 1.0f;
}

G8S:writeColor(R8G8S *dst,const gl:ColorI *src)
{
    dst->R = static_cast<int8_t>(java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 22
    dst-G=static_cast<int8_t>src-green)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

::writeColor(8 dst,const gl:ColorF *)
{
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
G :floatToNormalized(>)
}

void R8G8S::void ::(R32G32Sdst gl: *)
{
    dst->R = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
    dst->G = ->G = gl::floatToNormalized>reen;
}

void R8G8B8S::readColor
{
    dst->red   = src->R;
    dst->green = src->Gdst-R= :averagesrc1>,src2>)
    >= -B
    dst->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
}

void R8G8B8S::java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 1

>    :(rc>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    dst->green = gl::normalizedToFloatjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->blue  = gl:voidR32G32B32S:readColorgl:ColorF*st *rc)
    dst->alpha = 1.0f;
}

void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorI *    dst-green=gl:ormalizedToFloatsrc>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
    dst->R =     dst->alpha .fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    dst->G = static_cast<int8_t>(src->green);
blue);
}

void-R  <int32_t(-r);
{
Normalizedint8_t>src->ed;
    dst->G =    -B= static_cast<int32_t>(src->blue);
    dst->B = gl::floatToNormalized<int8_t>(src->blue);
}

 R8G8B8S:average(R8G8B8S *, const R8G8B8S src1 const R8G8B8S src2)
{
    dst-    -R= gl:floatToNormalized<nt32_t(src-red)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    dst-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->B = static_cast<{
}

dst> :-Gsrc2G;
{
    > =-R
    dst->green =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    -blue =src>;
    dst->alpha = src->A;
}

void java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
{
->red=gl:normalizedToFloat(>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    -green =gl:(src-G;
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = gl::normalizedToFloat(src->A);
}

void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorI *src)
{
    dst->R = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
    dst>G =static_cast<nt8_t>src>green);
    dst->B ={
    dst->    dst->red    gl::src-R;
}

void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<int8_t>(src->red);
    <int8_t>(src->reen);
    dst->B = gl::floatToNormalized<int8_t>(src->blue);
    dst->A = gl:: R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorI *src)
}

 *  R8G8B8A8S*java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
{
    dst-    -A (src>;
    dst->G = static_cast<int8_t>(gl::average(src1
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(src1-A -A)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

R16Sjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 54
{
    dst->red   = src->R;
   g ;
    dst->blue  = 0;
a ;
}

void R16S::readColor:*,
{
    dst->red   = gl::normalizedToFloat(src->R);
    >green=00f;
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

oidR16S:writeColor(R16S dst constgl:ColorI*)
{
    dst->R =    dst-G=gl:average(rc1->,src2-G)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

void R16S::writeColor(R16S *dst, const gl::ColorF *src)
{
:floatToNormalized<int16_t>(src->red);
}

void R16S::average(R16S *dst, const    -red    gl:float16ToFloat32src-R;
{
    dst->R = gl::average(src1->R, src2->R);
}

void R16G16S::readColor(gldst->alpha =gl:float16ToFloat32(rc>)
{
    dst->red   = src->R;
    dst->green = src-void A16B16G16R16F:riteColor( *dst,const gl: *)
    dst->blue  = 0;
= java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

void R16G16S::readColor(gl::ColorF *dst, const R16G16S     -A :float32ToFloat16src>;
{
    dst->red   = gl::normalizedToFloat(srcvoidA16B16G16R16F:average(A16B16G16R16F*dstjava.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R16G16S::writeColor(R16G16S *dst, const gl::ColorI *src)
{
(src>ed)
    dst->G = gl:averageHalfFloat(src1->,src2->B)
}

void R16G16S::writeColor(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
{
    dst-R :floatToNormalizedint16_t>src-red);
    dst->G = gl::floatToNormalized<int16_t>(src->green);
}

oidR16G16S:average( *,const R16G16S src1  R16G16Ssrc2
{
    ->R);
    dst->G = gl::average(src1->G    >java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
}

void R16G16B16S::readColor(gl::ColorI *dst, const R16G16B16S *src)
{
   dst-red    ->R;
    dst->green = src-dst- :>;
    dst->blue  = src->    dst->B = gl::float3>;
    dst>  
}

void R16G16B16S::readColorvoid java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 47
{
dst>=gl:normalizedToFloat(src-R;
    dst->green = gl::normalizedToFloat(src-{
        > gl:averageHalfFloatsrc1-R,src2>;
       ->lpha=10f;
}

void *dst  gl: src)
{
    dst->R = static_cast<int16_t>(src->red);
    dst->G = static_cast<int16_t>(src->greenjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->B = static_cast<int16_t>(src->blue);
}

void R16G16B16S::writeColor(R16G16B16S *dst, const gl::ColorF *src    -green = 00f;
{
    dst->R = gl::floatToNormalized<int16_t>(src->red);
    dst->G = gl::floatToNormalized<int16_t>(src->green);
    dst->B = gl::floatToNormalized<
}

void R16G16B16S::average(R16G16B16S *dst, const R16G16B16S *src1, const R16G16B16S *src2)
{
    dst->R = gl::average}
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
}

void R16G16B16A16S:: dst>=gl:averageHalfFloatsrc1-R -R;
{
    dst->red   = src-
    void A16F:eadColor(:ColorF*st,const A16F *src)
    dst->blue  = src->B;
    dst->alpha = src->A;{
}

void R16G16B16A16S::readColor(    dst-green =00f;
{
    -   =gl:src)
  :(-)
    
    dst->alpha = gl::normalizedToFloat(void A16F::writeColor(A16F *dst, const gl:
}

void R16G16B16A16S::writeColor(R16G16B16A16Sjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R = static_cast<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    >  static_cast>src>reen)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    dst->B = static_cast<int16_t>(src->blue
    dst->A = static_cast<int16_t>(src->alpha);
java.lang.StringIndexOutOfBoundsException: Range [20, 1) out of bounds for length 1

 R16G16B16A16S::riteColor(R16G16B16A16S *dst, const gl::ColorF *src)
{
    dst->R = gl::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 21
    dst->G = gl::floatToNormalized<int16_t>(src->green);
    dst->B = gl::floatToNormalizeddst-alpha = 1.f
    dst->A = gl::floatToNormalized<int16_t>(src->alpha);
}

void R16G16B16A16S::average(R16G16B16A16S *dst,
                            
                            const R16G16B16A16S *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst->G = glLgl:verageHalfFloatsrc1-L,>)java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
    dst->B = gljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->A = gl::average(src1->A, src2->{
}

 gl:* java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 54
{
    dst->red   = src->R;
    dst->green = 0;
    dst->blue  = 0;
dst-alpha = 1;
}

void R32S::readColor(gl::ColorF *dst, const java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 44
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = 0.0f;
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R32S::writeColor(R32S *dst, const gl    dst-> =gl:(src1>,src2-L;
{
   -R= static_cast<nt32_t(src->ed);
}

void R32S::writeColor(R32S *dst, const gl::java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
{
    dst->R = gl::floatToNormalized<int32_t>(src->red);
}

java.lang.StringIndexOutOfBoundsException: Range [40, 4) out of bounds for length 65
{
    dst->R = gl::average(    dst->green = gl::float16ToFloat32(src->G);
}

void R32G32S::    dst->alpha = 1.0f;
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = 0;
    dst->alpha = 1;
}

void R32G32S::readColor(gl::ColorF *dst, const R32G32S *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst
    blue  = .
    dst-
}

java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 61
{
    dst->R java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 66
    dst->G = static_cast<int32_t>java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void R32G32S::writeColor(R32G32S *dst,     dst->blue  = gl::float16ToFloat32(src
{
    dst->R = gl::floatToNormalized
    dst->G = gl::floatToNormalized<int32_t>(void R16G16B16F::writeColor(R16G16B16F *dst, co*)
}

void R32G32S::average(R32G32S *   >  :float32ToFloat16>;
{
    dst->R = gl:    >  :(-;
    dst->G = gl::average(dst->B = gl::float32ToFloat16blue;
}

void R32G32B32S::readColor(gl::ColorI *dst, void R16G16B16F::average(R16G16B16F *dst, const,constR16G16B16F*rc2
{
dst-red=src-;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = 1;
}

void R32G32B32S:
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src-    a=;
    dst->alpha =
}

void R32G32B32S::{
{
R=static_castint32_t(>)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
dst>  int32_tsrc>java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    dst->B = static_cast<int32_t>(}
}

void R32G32B32S::writeColor(void averageA,
{
dstR=gl:<int32_ts-red)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Range [42, 4) out of bounds for length 56
    dst->B = gl:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void R32G32B32S::average(R32G32B32S *dst, const java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 43
{
    dst->R = gl::average(src1->R, src2->R)}
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
}

void R32G32B32A32S::readColor(gl::ColorI *dst,{
{
dst-red=src-
    dst->green>  >;
    dstdst>   Bjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->alpha = src->A;
}

void R32G32B32A32S::readColor    >  -redjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
    dst->red   = gl::normalizedToFloat(-;
    
d-=njava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 47
    dst->alpha = gl::normalizedToFloat(const R32G32B32A32F
}

 :(gl:*)
{
    dstR <>(>;
    dst->G = static_cast-B=gl:src1>, >)
dst>  <(>)
    dst->A = static_cast<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void R32G32B32A32S::writeColor(R32G32B32A32S *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<int32_t>(src->red);
    dst->G = gl::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->B = gl::floatToNormalized<int32_t>(src->blue);
    dst->A = gl::floatToNormalized<int32_t>(src-    >=1.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

void R32G32B32A32S::average(R32G32B32A32S *dst,
                       R32G32B32A32S *,
                            const R32G32B32A32S *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst->G = gl::average(src1->G, src2-> dst> :> java.lang.StringIndexOutOfBoundsException: Range [41, 38) out of bounds for length 43
>:java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 43
    dst->A     r    .;


void A16B16G16R16F::readColor(gl::ColorF *java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 24
{
    dst->red   = gl::float16ToFloat32(src->R);
    - java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 24
   -gljava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 46
    dst->alpha = gl:    -A=:(rc1>,src2-A;
}

void A16B16G16R16F:
{
    dst->R = gl::float32ToFloat16(src->red);
    dst->G = gl::float32ToFloat16(srcvoid L32F:readColorgl:ColorFdst  L32F *src)
    dst->B = gl::float32ToFloat16(src->blue);
    {
}

void A16B16G16R16F:: dst->green=src->;
                            const A16B16G16R16F *src1,
                            A16B16G16R16F src2)
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->G = gl::averageHalfFloatvoid L32F:writeColor *dst, const gl::ColorF *src)
    dst->B = gl::averageHalfFloat(src1->java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 1
    dst->A = gl::averageHalfFloat(src1->A, src2->A);
}

:::R )
{
    dst-dstL=:> -;
    dst->green = gl::float16ToFloat32(src->G);
    dst->blue  = gl::float16ToFloat32(src->B);
    dst->alpha = gl::void L32A32F::readColor(gl *,constL32A32F src
}

R16G16B16A16F:RG16B16A16F const:ColorFsrc)
{
    dst->R = gl::float32ToFloat16(src->red);
    dst->G = gl::float32ToFloat16(src->green)dst->lue =src->;
    dst->B = gl::loat32ToFloat16(src-blue);
    dst->A = gljava.lang.StringIndexOutOfBoundsException: Range [15, 16) out of bounds for length 1
}

void R16G16B16A16F::average(R16G16B16A16F *dst,
                            const R16G16B16A16F *src1,
                            const R16G16B16A16F *src2)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->R = gl::averageHalfFloat(src1void L32A32F:average(L32A32F *st,const L32A32F *src1, const L32A32F src2)
    dst->G = gl::{
    dst->B = gl::averageHalfFloat(src1->B, src2->B);
       dst-> =gl:averageHalfFloatsrc1-A src2->)
}

java.lang.StringIndexOutOfBoundsException: Range [31, 4) out of bounds for length 54
{
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
- .;
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
    dst->alpha = 1.0f;dst> >java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

void R16Fvoid R32G32F:(R32G32F*,constgl:ColorFsrc)
{
dst  :-;
}

void R16F::averagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    dst->R = gl::averageHalfFloat(src1->R, src2->R);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void A16F::java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
dst-red=00java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   -green=0.fjava.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
    dst-blue=0.f;
    dst->alpha = gl::java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 22
}

void A16F::writeColor(A16F *dst, const void :R32G32B32F *,const gl:ColorF *)
{
    dst->A = gl::float32ToFloat16(src->alpha{
}

void A16F::average(A16F    -G=src-green;
{
    dst->A = gl::averageHalfFloat(    dst-B=src-blue;
}

void L16F::java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
{
    float lum  = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
    >ed   =lum;
    dst->green = lum;
    dst->blue  = lum;
    dst->alpha = 1.0f;
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->L = gl::float32ToFloat16(src->red{
}

void> ;
{
    dst->L = gl::averageHalfFloat(src1->L, src2->L);
}

void L16A16F::readColor(    ->alpha=src-A;
{
    float lum  = gl::java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    dst->red   = lum;
    dst->green = lum;
    dst->blue  = lum;
    dst->alpha = gl::float16ToFloat32(src->A);
}

void >  gl:normalizedToFloat2>src>);
{
    dst->L = gl::float32ToFloat16(src->red);
    dst->A = gl::float32ToFloat16(src->alpha);
}

    Rstatic_cast>redjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
    dst->L = gl::averageHalfFloat(src1->L,     dst->A = static_cast<uint32_t>(src->alpha
    dst->A = gl
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void R16G16F::readColor(gl::ColorF     -G=glf10 (-g;
{
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Range [44, 4) out of bounds for length 46
    dst->blue  = 0.0f
    dst->alpha = 1.0f;
}

void
{
    dst->R = gl::float32ToFloat16(src->red);
    dst->G = gl::float32ToFloat16(src->green    dst->G = gl:average(src1>,src2->)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

void R16G16F::average
{
dst>=gl:src1RR;
    dst->G = gljava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void R16G16B16F::readColor(    -java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 24
{
    dst->red   = gl::float16ToFloat32(src->R    -blue=gl:>src>)
   -green=gl:float16ToFloat32src>)
    dst->blue  = 
    dst->alpha = 1.0f;
}

voidR16G16B16F:writeColor(R16G16B16F dst const gl:ColorF *srcjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
{
    (src->;
    dst->G = gl::float32ToFloat16(src->green);
);
}

void R16G16B16F::average(R16G16B16F *dst, constjava.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 1
{
    dst->R = gl::averageHalfFloat(src1->R, src2->R);
    dst->G=gl:floatToNormalized10,int32_t>(rc-red
    dst-B java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 52
}

>  :<,int32_t(-alpha;
{
    dst->red   = src->R;
    dst->green v R10G10B10A2Saveragedst  java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 97
    -blue  =src->;
    dst->alpha = src->A;
}

 A32B32G32R32FwriteColor(A32B32G32R32F *dst, const gl::ColorF *src)
{
    dst->R = src->red;
    dst->G = src->green;
    dst->B = src->blue;
c->alpha;
}

void A32B32G32R32F(::ColorUIdst,java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 69
                            const java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 24
                            const A32B32G32R32F *src2)
{
   ->=gl:average(src1->R, src2->R);
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
    dst>A= gl::average(src1->A, src2->A);
}

void{
{
   dst->ed   =src->;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alphadst-green=gl:normalizedToFloat<>src>)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

void R32G32B32A32F::writeColor(R32G32B32A32F *dst, const gl: dst-alpha  10;
{
   dst-R = src-red
    dst->G = src->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    -> =src-blue
    dst->A = src->java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
}

void R32G32B32A32F::average(R32G32B32A32F *dst,
                             R32G32B32A32Fsrc1,
                            const R32G32B32A32F *src2)
{
    dst->R = gl::average(src1->R, src2->void R10G10B10X2::writeColor(R10G10B10X2 const gl:ColorF *src)
    dst->G = gl::average(src1->G, src2->G);
    dst-> =gl:average(src1->B, src2->B);
    dst->A = gl::average(    G :java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 61
}

void R32F::readColor(gl::ColorF *dst,   *srcjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
    dst->red   = src->R;
    >  0f;
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

 R32F:(32F dst const gl:ColorF *src)
{
    dst->R = src->red;
}

void R32F::average(R32F *dst, const R32F *java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
    dst>R =gl:average(->R src2-R)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

void
{
dstred   =00;
    dst->green = 0.0fjava.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 1
    dst-green  :normalizedToFloat>srcG;
dst>=>;
}

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

oidA32F:average(A32F dst  A32F src1 const  *)
{
    dst->A = gl::average
dstR java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 45

void
{
dst>=src->;
    dst->green = src->L;
    dst->blue  = src->L;
    dst->alpha = 1.0f;
}

 L32F( *dst  :ColorFsrc)
{
    dst->L = src->red;
}

, const L32F*rc2)
{
    dst->L = gl::average(src1->L, src2->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void L32A32F::readColor(gl::ColorF *    dst->R = gl::average(src1->R, src2-
{
    dst->red   = src->L;
dstg = src-L
    dst->blue  = src->L;
dst-alpha=src-A
}

void L32A32F::writeColor(L32A32F *void :readColor(gl: dst constR9G9B9E5*rc)
{
Ljava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 22
    dst->A = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
}

void L32A32F::average(L32A32F    java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 40
{
    dst-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->A = gl::average(src1->
}

::gl: *st  R32G32F)
{
    dst->red=src>;
    dst->green = src->G;
    dst->blue  = 0.0f;
dsta=1.fjava.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

, :ColorFsrc
{
    st>R  src>java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
dst-G=src-green
}

 *dst  R32G32F src1,const *rc2java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
{
    dst->R = gl::average(src1->R, src2->R);
    ->G);


void     dst->R = gl>)
{
->ed -R
    dst->green = srcjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->blue  = src->B;
    dst->alpha = 1.0f;
}

void R32G32B32F::writeColor(R32G32B32F *dst, const gl::ColorF *src)
{
    dst->R = src->red;
    dst->G = src->green;
    dst->B = src{
}

void R32G32B32F:Gjava.lang.StringIndexOutOfBoundsException: Range [31, 15) out of bounds for length 50
{
    dst->R = gljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(    dst->depth   = gl::normal24(-D
}

void R10G10B10A2:: D24S8::WriteDepthStencil    *)
{
    dst->red   = src->R    ->  :<24 >static_cast(->);
dst-g  -Gjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->blue  = src->B;
    dst->alpha=src-Ajava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

voids S
{
    dst->red   =void S8::WriteDep(S8*,  srcjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    -green = :normalizedToFloat(-G;
    dst->blue  = gl::normalizedToFloat<10>(src->B);
    dst:java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 61
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

void R10G10B10A2::writeColor(R10G10B10A2
{
dst>=ujava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 45
    dst->    -Dgl(java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 77
    dst->B =:*, java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 65
    dst-    -  :normalizedToFloat(rc-D x00ffffff
}

void R10G10B10A2::writeColor(R10G10B10A2 *dst, const
{
    dst->R = gl::floatToNormalized<10, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Range [34, 7) out of bounds for length 61
    dst-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

 :average *dst, constR10G10B10A2*, constjava.lang.StringIndexOutOfBoundsException: Range [88, 86) out of bounds for length 93
{
    dst->R = gl::average(src1->R, src2->R);
    dst>G =gl:average(rc1>G,src2->G;
    dst->B = gl::average(src1->B, src2->B);
    dst->A = gl::average(src1->A, src2->A);
}

voidR10G10B10A2S:readColor(gl: *dst,const R10G10B10A2S*)
{
    dst->red   = src->R
    dst->green = src-:(D32* srcjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    ->   >;
    dst->alpha = src->A;
}

::readColorgl:ColorF *dst constR10G10B10A2Ssrc)
{
    dst->red   = gl::normalizedToFloat<10>(src->R);
    dst-green =gl:normalizedToFloat<10>(src->)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    dst->blue  = gl::normalizedToFloat<10>(src->B);
    dst->alpha = gl::normalizedToFloat<2>(src->A);
}

void R10G10B10A2S::writeColor(R10G10B10A2S *dst,    -D static_castfloat(-depth)
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
    dst->R = static_cast<int32_t>(src->red)} // namespace angle
    dst->G = static_cast<int32_t>(src->green);
    dst->B = static_cast<int32_t>(src->blue);
    dst->A = static_cast<int32_t>(src->alpha);
}

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

void R10G10B10A2S::average(R10G10B10A2S *dst, const R10G10B10A2S *src1, const R10G10B10A2S *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
    dst->A = gl::average(src1->A, src2->A);
}

void R10G10B10X2::readColor(gl::ColorUI *dst, const R10G10B10X2 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = 0x3;
}

void R10G10B10X2::readColor(gl::ColorF *dst, const R10G10B10X2 *src)
{
    dst->red   = gl::normalizedToFloat<10>(src->R);
    dst->green = gl::normalizedToFloat<10>(src->G);
    dst->blue  = gl::normalizedToFloat<10>(src->B);
    dst->alpha = 1.0f;
}

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

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

void R10G10B10X2::average(R10G10B10X2 *dst, const R10G10B10X2 *src1, const R10G10B10X2 *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
}

void B10G10R10A2::readColor(gl::ColorUI *dst, const B10G10R10A2 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = src->A;
}

void B10G10R10A2::readColor(gl::ColorF *dst, const B10G10R10A2 *src)
{
    dst->red   = gl::normalizedToFloat<10>(src->R);
    dst->green = gl::normalizedToFloat<10>(src->G);
    dst->blue  = gl::normalizedToFloat<10>(src->B);
    dst->alpha = gl::normalizedToFloat<2>(src->A);
}

void B10G10R10A2::writeColor(B10G10R10A2 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint32_t>(src->red);
    dst->G = static_cast<uint32_t>(src->green);
    dst->B = static_cast<uint32_t>(src->blue);
    dst->A = static_cast<uint32_t>(src->alpha);
}

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

void B10G10R10A2::average(B10G10R10A2 *dst, const B10G10R10A2 *src1, const B10G10R10A2 *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
    dst->A = gl::average(src1->A, src2->A);
}

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

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

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

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

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

void R11G11B10F::readColor(gl::ColorF *dst, const R11G11B10F *src)
{
    dst->red   = gl::float11ToFloat32(src->R);
    dst->green = gl::float11ToFloat32(src->G);
    dst->blue  = gl::float10ToFloat32(src->B);
    dst->alpha = 1.0f;
}

void R11G11B10F::writeColor(R11G11B10F *dst, const gl::ColorF *src)
{
    dst->R = gl::float32ToFloat11(src->red);
    dst->G = gl::float32ToFloat11(src->green);
    dst->B = gl::float32ToFloat10(src->blue);
}

void R11G11B10F::average(R11G11B10F *dst, const R11G11B10F *src1, const R11G11B10F *src2)
{
    dst->R = gl::averageFloat11(src1->R, src2->R);
    dst->G = gl::averageFloat11(src1->G, src2->G);
    dst->B = gl::averageFloat10(src1->B, src2->B);
}

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

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

void S8::ReadDepthStencil(DepthStencil *dst, const S8 *src)
{
    dst->depth   = 0;
    dst->stencil = src->S;
}

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

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

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

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

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

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

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

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

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

void D32FS8X24::ReadDepthStencil(DepthStencil *dst, const D32FS8X24 *src)
{
    dst->depth   = src->D;
    dst->stencil = src->S;
}

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