Skip to content

A
angle
Commit 446a4477 by Geoff Lang Committed by Shannon Woods
Options

Added new image formats to match new ES3 formats and added read and write…

Added new image formats to match new ES3 formats and added read and write functions to various color types that they can represent. TRAC #23256 Signed-off-by: Jamie Madill Signed-off-by: Shannon Woods Author: Geoff Lang
parent 75ce3f21
Showing with 1797 additions and 213 deletions
src/common/mathutil.h
...@@ -377,6 +377,105 @@ inline float float10ToFloat32(unsigned short fp11) ...@@ -377,6 +377,105 @@ inline float float10ToFloat32(unsigned short fp11)
} }
} }
template <typename T>
inline float normalizedToFloat(T input)
{
META_ASSERT(std::numeric_limits<T>::is_integer);
const float inverseMax = 1.0f / std::numeric_limits<T>::max();
return input * inverseMax;
}
template <unsigned int inputBitCount, typename T>
inline float normalizedToFloat(T input)
{
META_ASSERT(std::numeric_limits<T>::is_integer);
META_ASSERT(inputBitCount < (sizeof(T) * 8));
const float inverseMax = 1.0f / ((1 << inputBitCount) - 1);
return input * inverseMax;
}
template <typename T>
inline T floatToNormalized(float input)
{
return std::numeric_limits<T>::max() * input + 0.5f;
}
template <unsigned int outputBitCount, typename T>
inline T floatToNormalized(float input)
{
META_ASSERT(outputBitCount < (sizeof(T) * 8));
return ((1 << outputBitCount) - 1) * input + 0.5f;
}
template <unsigned int inputBitCount, unsigned int inputBitStart, typename T>
inline T getShiftedData(T input)
{
META_ASSERT(inputBitCount + inputBitStart <= (sizeof(T) * 8));
const T mask = (1 << inputBitCount) - 1;
return (input >> inputBitStart) & mask;
}
template <unsigned int inputBitCount, unsigned int inputBitStart, typename T>
inline T shiftData(T input)
{
META_ASSERT(inputBitCount + inputBitStart <= (sizeof(T) * 8));
const T mask = (1 << inputBitCount) - 1;
return (input & mask) << inputBitStart;
}
inline unsigned char average(unsigned char a, unsigned char b)
{
return ((a ^ b) >> 1) + (a & b);
}
inline signed char average(signed char a, signed char b)
{
return ((short)a + (short)b) / 2;
}
inline unsigned short average(unsigned short a, unsigned short b)
{
return ((a ^ b) >> 1) + (a & b);
}
inline signed short average(signed short a, signed short b)
{
return ((int)a + (int)b) / 2;
}
inline unsigned int average(unsigned int a, unsigned int b)
{
return ((a ^ b) >> 1) + (a & b);
}
inline signed int average(signed int a, signed int b)
{
return ((long long)a + (long long)b) / 2;
}
inline float average(float a, float b)
{
return (a + b) * 0.5f;
}
inline unsigned short averageHalfFloat(unsigned short a, unsigned short b)
{
return float32ToFloat16((float16ToFloat32(a) + float16ToFloat32(b)) * 0.5f);
}
inline unsigned int averageFloat11(unsigned int a, unsigned int b)
{
return float32ToFloat11((float11ToFloat32(a) + float11ToFloat32(b)) * 0.5f);
}
inline unsigned int averageFloat10(unsigned int a, unsigned int b)
{
return float32ToFloat10((float10ToFloat32(a) + float10ToFloat32(b)) * 0.5f);
}
} }
namespace rx namespace rx
......
src/libGLESv2/renderer/imageformats.h
...@@ -10,16 +10,36 @@ ...@@ -10,16 +10,36 @@
#ifndef LIBGLESV2_RENDERER_IMAGEFORMATS_H_ #ifndef LIBGLESV2_RENDERER_IMAGEFORMATS_H_
#define LIBGLESV2_RENDERER_IMAGEFORMATS_H_ #define LIBGLESV2_RENDERER_IMAGEFORMATS_H_
#include "libGLESv2/angletypes.h"
namespace rx namespace rx
{ {
// Several structures share functionality for reading, writing or mipmapping but the layout
// must match the texture format which the structure represents. If collapsing or typedefing
// structs in this header, make sure the functionality and memory layout is exactly the same.
struct L8 struct L8
{ {
unsigned char L; unsigned char L;
static void 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;
}
static void writeColor(L8 *dst, const gl::ColorF *src)
{
dst->L = gl::floatToNormalized<unsigned char>((src->red + src->green + src->blue) / 3.0f);
}
static void average(L8 *dst, const L8 *src1, const L8 *src2) static void average(L8 *dst, const L8 *src1, const L8 *src2)
{ {
dst->L = ((src1->L ^ src2->L) >> 1) + (src1->L & src2->L); dst->L = gl::average(src1->L, src2->L);
} }
}; };
...@@ -27,9 +47,35 @@ struct R8 ...@@ -27,9 +47,35 @@ struct R8
{ {
unsigned char R; unsigned char R;
static void 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;
}
static void readColor(gl::ColorUI *dst, const R8 *src)
{
dst->red = src->R;
dst->green = 0;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R8 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned char>(src->red);
}
static void writeColor(R8 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned char>(src->red);
}
static void average(R8 *dst, const R8 *src1, const R8 *src2) static void average(R8 *dst, const R8 *src1, const R8 *src2)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); dst->R = gl::average(src1->R, src2->R);
} }
}; };
...@@ -37,17 +83,71 @@ struct A8 ...@@ -37,17 +83,71 @@ struct A8
{ {
unsigned char A; unsigned char A;
static void readColor(gl::ColorF *dst, const A8 *src)
{
dst->red = 0.0f;
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = gl::normalizedToFloat(src->A);
}
static void writeColor(A8 *dst, const gl::ColorF *src)
{
dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
}
static void average(A8 *dst, const A8 *src1, const A8 *src2) static void average(A8 *dst, const A8 *src1, const A8 *src2)
{ {
dst->A = ((src1->A ^ src2->A) >> 1) + (src1->A & src2->A); dst->A = gl::average(src1->A, src2->A);
} }
}; };
struct A8L8 struct L8A8
{ {
unsigned char L; unsigned char L;
unsigned char A; unsigned char A;
static void readColor(gl::ColorF *dst, const L8A8 *src)
{
const float lum = gl::normalizedToFloat(src->L);
dst->red = lum;
dst->green = lum;
dst->blue = lum;
dst->alpha = gl::normalizedToFloat(src->A);
}
static void writeColor(L8A8 *dst, const gl::ColorF *src)
{
dst->L = gl::floatToNormalized<unsigned char>((src->red + src->green + src->blue) / 3.0f);
dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
}
static void average(L8A8 *dst, const L8A8 *src1, const L8A8 *src2)
{
*(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2);
}
};
struct A8L8
{
unsigned char A;
unsigned char L;
static void readColor(gl::ColorF *dst, const A8L8 *src)
{
const float lum = gl::normalizedToFloat(src->L);
dst->red = lum;
dst->green = lum;
dst->blue = lum;
dst->alpha = gl::normalizedToFloat(src->A);
}
static void writeColor(A8L8 *dst, const gl::ColorF *src)
{
dst->L = gl::floatToNormalized<unsigned char>((src->red + src->green + src->blue) / 3.0f);
dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
}
static void average(A8L8 *dst, const A8L8 *src1, const A8L8 *src2) static void average(A8L8 *dst, const A8L8 *src1, const A8L8 *src2)
{ {
*(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2); *(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2);
...@@ -59,362 +159,1656 @@ struct R8G8 ...@@ -59,362 +159,1656 @@ struct R8G8
unsigned char R; unsigned char R;
unsigned char G; unsigned char G;
static void readColor(gl::ColorF *dst, const R8G8 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R8G8 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R8G8 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned char>(src->red);
dst->G = gl::floatToNormalized<unsigned char>(src->green);
}
static void writeColor(R8G8 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned char>(src->red);
dst->G = static_cast<unsigned char>(src->green);
}
static void average(R8G8 *dst, const R8G8 *src1, const R8G8 *src2) static void average(R8G8 *dst, const R8G8 *src1, const R8G8 *src2)
{ {
*(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2); *(unsigned short*)dst = (((*(unsigned short*)src1 ^ *(unsigned short*)src2) & 0xFEFE) >> 1) + (*(unsigned short*)src1 & *(unsigned short*)src2);
} }
}; };
struct R8G8B8
{
unsigned char R;
unsigned char G;
unsigned char B;
static void readColor(gl::ColorF *dst, const R8G8B8 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R8G8B8 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->G;
dst->alpha = 0;
}
static void writeColor(R8G8B8 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned char>(src->red);
dst->G = gl::floatToNormalized<unsigned char>(src->green);
dst->B = gl::floatToNormalized<unsigned char>(src->blue);
}
static void writeColor(R8G8B8 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned char>(src->red);
dst->G = static_cast<unsigned char>(src->green);
dst->B = static_cast<unsigned char>(src->blue);
}
static void average(R8G8B8 *dst, const R8G8B8 *src1, const R8G8B8 *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);
}
};
struct B8G8R8
{
unsigned char B;
unsigned char G;
unsigned char R;
static void readColor(gl::ColorF *dst, const B8G8R8 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const B8G8R8 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->G;
dst->alpha = 0;
}
static void writeColor(B8G8R8 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned char>(src->red);
dst->G = gl::floatToNormalized<unsigned char>(src->green);
dst->B = gl::floatToNormalized<unsigned char>(src->blue);
}
static void writeColor(B8G8R8 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned char>(src->red);
dst->G = static_cast<unsigned char>(src->green);
dst->B = static_cast<unsigned char>(src->blue);
}
static void average(B8G8R8 *dst, const B8G8R8 *src1, const B8G8R8 *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);
}
};
struct R5G6B5
{
unsigned short RGB;
static void readColor(gl::ColorF *dst, const R5G6B5 *src)
{
dst->red = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->RGB));
dst->green = gl::normalizedToFloat<6>(gl::getShiftedData<6, 5>(src->RGB));
dst->blue = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->RGB));
dst->alpha = 1.0f;
}
static void writeColor(R5G6B5 *dst, const gl::ColorF *src)
{
dst->RGB = gl::shiftData<5, 11>(gl::floatToNormalized<5, unsigned short>(src->red)) |
gl::shiftData<6, 5>(gl::floatToNormalized<6, unsigned short>(src->green)) |
gl::shiftData<5, 0>(gl::floatToNormalized<5, unsigned short>(src->blue));
}
static void average(R5G6B5 *dst, const R5G6B5 *src1, const R5G6B5 *src2)
{
dst->RGB = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->RGB), gl::getShiftedData<5, 11>(src2->RGB))) |
gl::shiftData<6, 5>(gl::average(gl::getShiftedData<6, 5>(src1->RGB), gl::getShiftedData<6, 5>(src2->RGB))) |
gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->RGB), gl::getShiftedData<5, 0>(src2->RGB)));
}
};
struct A8R8G8B8 struct A8R8G8B8
{ {
unsigned char A;
unsigned char R;
unsigned char G;
unsigned char B;
static void readColor(gl::ColorF *dst, const A8R8G8B8 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
}
static void readColor(gl::ColorUI *dst, const A8R8G8B8 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(A8R8G8B8 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned char>(src->red);
dst->G = gl::floatToNormalized<unsigned char>(src->green);
dst->B = gl::floatToNormalized<unsigned char>(src->blue);
dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
}
static void writeColor(A8R8G8B8 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned char>(src->red);
dst->G = static_cast<unsigned char>(src->green);
dst->B = static_cast<unsigned char>(src->blue);
dst->A = static_cast<unsigned char>(src->alpha);
}
static void average(A8R8G8B8 *dst, const A8R8G8B8 *src1, const A8R8G8B8 *src2)
{
*(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2);
}
};
struct R8G8B8A8
{
unsigned char R;
unsigned char G;
unsigned char B;
unsigned char A;
static void readColor(gl::ColorF *dst, const R8G8B8A8 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
}
static void readColor(gl::ColorUI *dst, const R8G8B8A8 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(R8G8B8A8 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned char>(src->red);
dst->G = gl::floatToNormalized<unsigned char>(src->green);
dst->B = gl::floatToNormalized<unsigned char>(src->blue);
dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
}
static void writeColor(R8G8B8A8 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned char>(src->red);
dst->G = static_cast<unsigned char>(src->green);
dst->B = static_cast<unsigned char>(src->blue);
dst->A = static_cast<unsigned char>(src->alpha);
}
static void average(R8G8B8A8 *dst, const R8G8B8A8 *src1, const R8G8B8A8 *src2)
{
*(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2);
}
};
struct B8G8R8A8
{
unsigned char B; unsigned char B;
unsigned char G; unsigned char G;
unsigned char R; unsigned char R;
unsigned char A; unsigned char A;
static void average(A8R8G8B8 *dst, const A8R8G8B8 *src1, const A8R8G8B8 *src2) static void readColor(gl::ColorF *dst, const B8G8R8A8 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
}
static void readColor(gl::ColorUI *dst, const B8G8R8A8 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(B8G8R8A8 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned char>(src->red);
dst->G = gl::floatToNormalized<unsigned char>(src->green);
dst->B = gl::floatToNormalized<unsigned char>(src->blue);
dst->A = gl::floatToNormalized<unsigned char>(src->alpha);
}
static void writeColor(B8G8R8A8 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned char>(src->red);
dst->G = static_cast<unsigned char>(src->green);
dst->B = static_cast<unsigned char>(src->blue);
dst->A = static_cast<unsigned char>(src->alpha);
}
static void average(B8G8R8A8 *dst, const B8G8R8A8 *src1, const B8G8R8A8 *src2)
{
*(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2);
}
};
struct B5G5R5A1
{
unsigned short BGRA;
static void readColor(gl::ColorF *dst, const B5G5R5A1 *src)
{
dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 15>(src->BGRA));
dst->red = gl::normalizedToFloat<5>(gl::getShiftedData<5, 10>(src->BGRA));
dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5, 5>(src->BGRA));
dst->blue = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->BGRA));
}
static void writeColor(B5G5R5A1 *dst, const gl::ColorF *src)
{
dst->BGRA = gl::shiftData<1, 15>(gl::floatToNormalized<1, unsigned short>(src->alpha)) |
gl::shiftData<5, 10>(gl::floatToNormalized<5, unsigned short>(src->red)) |
gl::shiftData<5, 5>(gl::floatToNormalized<5, unsigned short>(src->green)) |
gl::shiftData<5, 0>(gl::floatToNormalized<5, unsigned short>(src->blue));
}
static void average(B5G5R5A1 *dst, const B5G5R5A1 *src1, const B5G5R5A1 *src2)
{
dst->BGRA = gl::shiftData<1, 15>(gl::average(gl::getShiftedData<1, 15>(src1->BGRA), gl::getShiftedData<1, 15>(src2->BGRA))) |
gl::shiftData<5, 10>(gl::average(gl::getShiftedData<5, 10>(src1->BGRA), gl::getShiftedData<5, 10>(src2->BGRA))) |
gl::shiftData<5, 5>(gl::average(gl::getShiftedData<5, 5>(src1->BGRA), gl::getShiftedData<5, 5>(src2->BGRA))) |
gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->BGRA), gl::getShiftedData<5, 0>(src2->BGRA)));
}
};
struct R5G5B5A1
{
unsigned short RGBA;
static void readColor(gl::ColorF *dst, const R5G5B5A1 *src)
{
dst->alpha = gl::normalizedToFloat<1>(gl::getShiftedData<1, 15>(src->RGBA));
dst->blue = gl::normalizedToFloat<5>(gl::getShiftedData<5, 10>(src->RGBA));
dst->green = gl::normalizedToFloat<5>(gl::getShiftedData<5, 5>(src->RGBA));
dst->red = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->RGBA));
}
static void writeColor(R5G5B5A1 *dst, const gl::ColorF *src)
{
dst->RGBA = gl::shiftData<1, 15>(gl::floatToNormalized<1, unsigned short>(src->alpha)) |
gl::shiftData<5, 10>(gl::floatToNormalized<5, unsigned short>(src->blue)) |
gl::shiftData<5, 5>(gl::floatToNormalized<5, unsigned short>(src->green)) |
gl::shiftData<5, 0>(gl::floatToNormalized<5, unsigned short>(src->red));
}
static void average(R5G5B5A1 *dst, const R5G5B5A1 *src1, const R5G5B5A1 *src2)
{
dst->RGBA = gl::shiftData<1, 15>(gl::average(gl::getShiftedData<1, 15>(src1->RGBA), gl::getShiftedData<1, 15>(src2->RGBA))) |
gl::shiftData<5, 10>(gl::average(gl::getShiftedData<5, 10>(src1->RGBA), gl::getShiftedData<5, 10>(src2->RGBA))) |
gl::shiftData<5, 5>(gl::average(gl::getShiftedData<5, 5>(src1->RGBA), gl::getShiftedData<5, 5>(src2->RGBA))) |
gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->RGBA), gl::getShiftedData<5, 0>(src2->RGBA)));
}
};
struct R4G4B4A4
{
unsigned char R : 4;
unsigned char G : 4;
unsigned char B : 4;
unsigned char A : 4;
static void readColor(gl::ColorF *dst, const R4G4B4A4 *src)
{
dst->red = gl::normalizedToFloat<4>(src->R);
dst->green = gl::normalizedToFloat<4>(src->G);
dst->blue = gl::normalizedToFloat<4>(src->B);
dst->alpha = gl::normalizedToFloat<4>(src->A);
}
static void writeColor(R4G4B4A4 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<4, unsigned char>(src->red);
dst->G = gl::floatToNormalized<4, unsigned char>(src->green);
dst->B = gl::floatToNormalized<4, unsigned char>(src->blue);
dst->A = gl::floatToNormalized<4, unsigned char>(src->alpha);
}
static void average(R4G4B4A4 *dst, const R4G4B4A4 *src1, const R4G4B4A4 *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);
}
};
struct A4R4G4B4
{
unsigned char A : 4;
unsigned char R : 4;
unsigned char G : 4;
unsigned char B : 4;
static void readColor(gl::ColorF *dst, const A4R4G4B4 *src)
{
dst->red = gl::normalizedToFloat<4>(src->R);
dst->green = gl::normalizedToFloat<4>(src->G);
dst->blue = gl::normalizedToFloat<4>(src->B);
dst->alpha = gl::normalizedToFloat<4>(src->A);
}
static void writeColor(A4R4G4B4 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<4, unsigned char>(src->red);
dst->G = gl::floatToNormalized<4, unsigned char>(src->green);
dst->B = gl::floatToNormalized<4, unsigned char>(src->blue);
dst->A = gl::floatToNormalized<4, unsigned char>(src->alpha);
}
static void average(A4R4G4B4 *dst, const A4R4G4B4 *src1, const A4R4G4B4 *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);
}
};
struct B4G4R4A4
{
unsigned char B : 4;
unsigned char G : 4;
unsigned char R : 4;
unsigned char A : 4;
static void readColor(gl::ColorF *dst, const B4G4R4A4 *src)
{
dst->red = gl::normalizedToFloat<4>(src->R);
dst->green = gl::normalizedToFloat<4>(src->G);
dst->blue = gl::normalizedToFloat<4>(src->B);
dst->alpha = gl::normalizedToFloat<4>(src->A);
}
static void writeColor(B4G4R4A4 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<4, unsigned char>(src->red);
dst->G = gl::floatToNormalized<4, unsigned char>(src->green);
dst->B = gl::floatToNormalized<4, unsigned char>(src->blue);
dst->A = gl::floatToNormalized<4, unsigned char>(src->alpha);
}
static void average(B4G4R4A4 *dst, const B4G4R4A4 *src1, const B4G4R4A4 *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);
}
};
struct R16
{
unsigned short R;
static void readColor(gl::ColorF *dst, const R16 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R16 *src)
{
dst->red = src->R;
dst->green = 0;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R16 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned short>(src->red);
}
static void writeColor(R16 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned short>(src->red);
}
static void average(R16 *dst, const R16 *src1, const R16 *src2)
{
dst->R = gl::average(src1->R, src2->R);
}
};
struct R16G16
{
unsigned short R;
unsigned short G;
static void readColor(gl::ColorF *dst, const R16G16 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R16G16 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R16G16 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned short>(src->red);
dst->G = gl::floatToNormalized<unsigned short>(src->green);
}
static void writeColor(R16G16 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned short>(src->red);
dst->G = static_cast<unsigned short>(src->green);
}
static void average(R16G16 *dst, const R16G16 *src1, const R16G16 *src2)
{
dst->R = gl::average(src1->R, src2->R);
dst->G = gl::average(src1->G, src2->G);
}
};
struct R16G16B16
{
unsigned short R;
unsigned short G;
unsigned short B;
static void readColor(gl::ColorF *dst, const R16G16B16 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R16G16B16 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = 0;
}
static void writeColor(R16G16B16 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned short>(src->red);
dst->G = gl::floatToNormalized<unsigned short>(src->green);
dst->B = gl::floatToNormalized<unsigned short>(src->blue);
}
static void writeColor(R16G16B16 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned short>(src->red);
dst->G = static_cast<unsigned short>(src->green);
dst->B = static_cast<unsigned short>(src->blue);
}
static void average(R16G16B16 *dst, const R16G16B16 *src1, const R16G16B16 *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);
}
};
struct R16G16B16A16
{
unsigned short R;
unsigned short G;
unsigned short B;
unsigned short A;
static void readColor(gl::ColorF *dst, const R16G16B16A16 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
}
static void readColor(gl::ColorUI *dst, const R16G16B16A16 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(R16G16B16A16 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned short>(src->red);
dst->G = gl::floatToNormalized<unsigned short>(src->green);
dst->B = gl::floatToNormalized<unsigned short>(src->blue);
dst->A = gl::floatToNormalized<unsigned short>(src->alpha);
}
static void writeColor(R16G16B16A16 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned short>(src->red);
dst->G = static_cast<unsigned short>(src->green);
dst->B = static_cast<unsigned short>(src->blue);
dst->A = static_cast<unsigned short>(src->alpha);
}
static void average(R16G16B16A16 *dst, const R16G16B16A16 *src1, const R16G16B16A16 *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);
}
};
struct R32
{
unsigned int R;
static void readColor(gl::ColorF *dst, const R32 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R32 *src)
{
dst->red = src->R;
dst->green = 0;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R32 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned int>(src->red);
}
static void writeColor(R32 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned int>(src->red);
}
static void average(R32 *dst, const R32 *src1, const R32 *src2)
{
dst->R = gl::average(src1->R, src2->R);
}
};
struct R32G32
{
unsigned int R;
unsigned int G;
static void readColor(gl::ColorF *dst, const R32G32 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R32G32 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R32G32 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned int>(src->red);
dst->G = gl::floatToNormalized<unsigned int>(src->green);
}
static void writeColor(R32G32 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned int>(src->red);
dst->G = static_cast<unsigned int>(src->green);
}
static void average(R32G32 *dst, const R32G32 *src1, const R32G32 *src2)
{
dst->R = gl::average(src1->R, src2->R);
dst->G = gl::average(src1->G, src2->G);
}
};
struct R32G32B32
{
unsigned int R;
unsigned int G;
unsigned int B;
static void readColor(gl::ColorF *dst, const R32G32B32 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = 1.0f;
}
static void readColor(gl::ColorUI *dst, const R32G32B32 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = 0;
}
static void writeColor(R32G32B32 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned int>(src->red);
dst->G = gl::floatToNormalized<unsigned int>(src->green);
dst->B = gl::floatToNormalized<unsigned int>(src->blue);
}
static void writeColor(R32G32B32 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned int>(src->red);
dst->G = static_cast<unsigned int>(src->green);
dst->B = static_cast<unsigned int>(src->blue);
}
static void average(R32G32B32 *dst, const R32G32B32 *src1, const R32G32B32 *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);
}
};
struct R32G32B32A32
{
unsigned int R;
unsigned int G;
unsigned int B;
unsigned int A;
static void readColor(gl::ColorF *dst, const R32G32B32A32 *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
}
static void readColor(gl::ColorUI *dst, const R32G32B32A32 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(R32G32B32A32 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<unsigned int>(src->red);
dst->G = gl::floatToNormalized<unsigned int>(src->green);
dst->B = gl::floatToNormalized<unsigned int>(src->blue);
dst->A = gl::floatToNormalized<unsigned int>(src->alpha);
}
static void writeColor(R32G32B32A32 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned int>(src->red);
dst->G = static_cast<unsigned int>(src->green);
dst->B = static_cast<unsigned int>(src->blue);
dst->A = static_cast<unsigned int>(src->alpha);
}
static void average(R32G32B32A32 *dst, const R32G32B32A32 *src1, const R32G32B32A32 *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);
}
};
struct R8S
{
char R;
static void readColor(gl::ColorF *dst, const R8S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R8S *src)
{
dst->red = src->R;
dst->green = 0;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R8S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<char>(src->red);
}
static void writeColor(R8S *dst, const gl::ColorI *src)
{
dst->R = static_cast<char>(src->red);
}
static void average(R8S *dst, const R8S *src1, const R8S *src2)
{
dst->R = gl::average(src1->R, src2->R);
}
};
struct R8G8S
{
char R;
char G;
static void readColor(gl::ColorF *dst, const R8G8S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R8G8S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R8G8S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<char>(src->red);
dst->G = gl::floatToNormalized<char>(src->green);
}
static void writeColor(R8G8S *dst, const gl::ColorI *src)
{
dst->R = static_cast<char>(src->red);
dst->G = static_cast<char>(src->green);
}
static void average(R8G8S *dst, const R8G8S *src1, const R8G8S *src2)
{
dst->R = gl::average(src1->R, src2->R);
dst->G = gl::average(src1->G, src2->G);
}
};
struct R8G8B8S
{
char R;
char G;
char B;
static void readColor(gl::ColorF *dst, const R8G8B8S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R8G8B8S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = 0;
}
static void writeColor(R8G8B8S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<char>(src->red);
dst->G = gl::floatToNormalized<char>(src->green);
dst->B = gl::floatToNormalized<char>(src->blue);
}
static void writeColor(R8G8B8S *dst, const gl::ColorI *src)
{
dst->R = static_cast<char>(src->red);
dst->G = static_cast<char>(src->green);
dst->B = static_cast<char>(src->blue);
}
static void average(R8G8B8S *dst, const R8G8B8S *src1, const R8G8B8S *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);
}
};
struct R8G8B8A8S
{
char R;
char G;
char B;
char A;
static void readColor(gl::ColorF *dst, const R8G8B8A8S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
}
static void readColor(gl::ColorI *dst, const R8G8B8A8S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(R8G8B8A8S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<char>(src->red);
dst->G = gl::floatToNormalized<char>(src->green);
dst->B = gl::floatToNormalized<char>(src->blue);
dst->A = gl::floatToNormalized<char>(src->alpha);
}
static void writeColor(R8G8B8A8S *dst, const gl::ColorI *src)
{
dst->R = static_cast<char>(src->red);
dst->G = static_cast<char>(src->green);
dst->B = static_cast<char>(src->blue);
dst->A = static_cast<char>(src->alpha);
}
static void average(R8G8B8A8S *dst, const R8G8B8A8S *src1, const R8G8B8A8S *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);
}
};
struct R16S
{
short R;
static void readColor(gl::ColorF *dst, const R16S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R16S *src)
{
dst->red = src->R;
dst->green = 0;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R16S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<short>(src->red);
}
static void writeColor(R16S *dst, const gl::ColorI *src)
{
dst->R = static_cast<short>(src->red);
}
static void average(R16S *dst, const R16S *src1, const R16S *src2)
{
dst->R = gl::average(src1->R, src2->R);
}
};
struct R16G16S
{
short R;
short G;
static void readColor(gl::ColorF *dst, const R16G16S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R16G16S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R16G16S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<short>(src->red);
dst->G = gl::floatToNormalized<short>(src->green);
}
static void writeColor(R16G16S *dst, const gl::ColorI *src)
{
dst->R = static_cast<short>(src->red);
dst->G = static_cast<short>(src->green);
}
static void average(R16G16S *dst, const R16G16S *src1, const R16G16S *src2)
{
dst->R = gl::average(src1->R, src2->R);
dst->G = gl::average(src1->G, src2->G);
}
};
struct R16G16B16S
{
short R;
short G;
short B;
static void readColor(gl::ColorF *dst, const R16G16B16S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R16G16B16S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = 0;
}
static void writeColor(R16G16B16S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<short>(src->red);
dst->G = gl::floatToNormalized<short>(src->green);
dst->B = gl::floatToNormalized<short>(src->blue);
}
static void writeColor(R16G16B16S *dst, const gl::ColorI *src)
{
dst->R = static_cast<short>(src->red);
dst->G = static_cast<short>(src->green);
dst->B = static_cast<short>(src->blue);
}
static void average(R16G16B16S *dst, const R16G16B16S *src1, const R16G16B16S *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);
}
};
struct R16G16B16A16S
{
short R;
short G;
short B;
short A;
static void readColor(gl::ColorF *dst, const R16G16B16A16S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
}
static void readColor(gl::ColorI *dst, const R16G16B16A16S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(R16G16B16A16S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<short>(src->red);
dst->G = gl::floatToNormalized<short>(src->green);
dst->B = gl::floatToNormalized<short>(src->blue);
dst->A = gl::floatToNormalized<short>(src->alpha);
}
static void writeColor(R16G16B16A16S *dst, const gl::ColorI *src)
{
dst->R = static_cast<short>(src->red);
dst->G = static_cast<short>(src->green);
dst->B = static_cast<short>(src->blue);
dst->A = static_cast<short>(src->alpha);
}
static void average(R16G16B16A16S *dst, const R16G16B16A16S *src1, const R16G16B16A16S *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);
}
};
struct R32S
{
int R;
static void readColor(gl::ColorF *dst, const R32S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R32S *src)
{
dst->red = src->R;
dst->green = 0;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R32S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<int>(src->red);
}
static void writeColor(R32S *dst, const gl::ColorI *src)
{
dst->R = static_cast<int>(src->red);
}
static void average(R32S *dst, const R32S *src1, const R32S *src2)
{
dst->R = gl::average(src1->R, src2->R);
}
};
struct R32G32S
{
int R;
int G;
static void readColor(gl::ColorF *dst, const R32G32S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R32G32S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = 0;
dst->alpha = 0;
}
static void writeColor(R32G32S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<int>(src->red);
dst->G = gl::floatToNormalized<int>(src->green);
}
static void writeColor(R32G32S *dst, const gl::ColorI *src)
{
dst->R = static_cast<int>(src->red);
dst->G = static_cast<int>(src->green);
}
static void average(R32G32S *dst, const R32G32S *src1, const R32G32S *src2)
{
dst->R = gl::average(src1->R, src2->R);
dst->G = gl::average(src1->G, src2->G);
}
};
struct R32G32B32S
{
int R;
int G;
int B;
static void readColor(gl::ColorF *dst, const R32G32B32S *src)
{
dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = 1.0f;
}
static void readColor(gl::ColorI *dst, const R32G32B32S *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = 0;
}
static void writeColor(R32G32B32S *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<int>(src->red);
dst->G = gl::floatToNormalized<int>(src->green);
dst->B = gl::floatToNormalized<int>(src->blue);
}
static void writeColor(R32G32B32S *dst, const gl::ColorI *src)
{
dst->R = static_cast<int>(src->red);
dst->G = static_cast<int>(src->green);
dst->B = static_cast<int>(src->blue);
}
static void average(R32G32B32S *dst, const R32G32B32S *src1, const R32G32B32S *src2)
{ {
*(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)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);
} }
}; };
struct R8G8B8A8 struct R32G32B32A32S
{ {
unsigned char R; int R;
unsigned char G; int G;
unsigned char B; int B;
unsigned char A; int A;
static void average(R8G8B8A8 *dst, const R8G8B8A8 *src1, const R8G8B8A8 *src2) static void readColor(gl::ColorF *dst, const R32G32B32A32S *src)
{ {
*(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2); dst->red = gl::normalizedToFloat(src->R);
dst->green = gl::normalizedToFloat(src->G);
dst->blue = gl::normalizedToFloat(src->B);
dst->alpha = gl::normalizedToFloat(src->A);
} }
};
struct B8G8R8A8 static void readColor(gl::ColorI *dst, const R32G32B32A32S *src)
{ {
unsigned char B; dst->red = src->R;
unsigned char G; dst->green = src->G;
unsigned char R; dst->blue = src->B;
unsigned char A; dst->alpha = src->A;
}
static void average(B8G8R8A8 *dst, const B8G8R8A8 *src1, const B8G8R8A8 *src2) static void writeColor(R32G32B32A32S *dst, const gl::ColorF *src)
{ {
*(unsigned int*)dst = (((*(unsigned int*)src1 ^ *(unsigned int*)src2) & 0xFEFEFEFE) >> 1) + (*(unsigned int*)src1 & *(unsigned int*)src2); dst->R = gl::floatToNormalized<int>(src->red);
dst->G = gl::floatToNormalized<int>(src->green);
dst->B = gl::floatToNormalized<int>(src->blue);
dst->A = gl::floatToNormalized<int>(src->alpha);
} }
};
struct R16 static void writeColor(R32G32B32A32S *dst, const gl::ColorI *src)
{ {
unsigned short R; dst->R = static_cast<int>(src->red);
dst->G = static_cast<int>(src->green);
dst->B = static_cast<int>(src->blue);
dst->A = static_cast<int>(src->alpha);
}
static void average(R16 *dst, const R16 *src1, const R16 *src2) static void average(R32G32B32A32S *dst, const R32G32B32A32S *src1, const R32G32B32A32S *src2)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); 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);
} }
}; };
struct R16G16 struct A16B16G16R16F
{ {
unsigned short A;
unsigned short R; unsigned short R;
unsigned short G; unsigned short G;
unsigned short B;
static void average(R16G16 *dst, const R16G16 *src1, const R16G16 *src2) static void readColor(gl::ColorF *dst, const A16B16G16R16F *src)
{
dst->red = gl::float16ToFloat32(src->R);
dst->green = gl::float16ToFloat32(src->G);
dst->blue = gl::float16ToFloat32(src->B);
dst->alpha = gl::float16ToFloat32(src->A);
}
static void writeColor(A16B16G16R16F *dst, const gl::ColorF *src)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); dst->R = gl::float32ToFloat16(src->red);
dst->G = ((src1->G ^ src2->G) >> 1) + (src1->G & src2->G); dst->G = gl::float32ToFloat16(src->green);
dst->B = gl::float32ToFloat16(src->blue);
dst->A = gl::float32ToFloat16(src->alpha);
}
static void average(A16B16G16R16F *dst, const A16B16G16R16F *src1, const A16B16G16R16F *src2)
{
dst->R = gl::averageHalfFloat(src1->R, src2->R);
dst->G = gl::averageHalfFloat(src1->G, src2->G);
dst->B = gl::averageHalfFloat(src1->B, src2->B);
dst->A = gl::averageHalfFloat(src1->A, src2->A);
} }
}; };
struct R16G16B16A16 struct R16G16B16A16F
{ {
unsigned short R; unsigned short R;
unsigned short G; unsigned short G;
unsigned short B; unsigned short B;
unsigned short A; unsigned short A;
static void average(R16G16B16A16 *dst, const R16G16B16A16 *src1, const R16G16B16A16 *src2) static void readColor(gl::ColorF *dst, const R16G16B16A16F *src)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); dst->red = gl::float16ToFloat32(src->R);
dst->G = ((src1->G ^ src2->G) >> 1) + (src1->G & src2->G); dst->green = gl::float16ToFloat32(src->G);
dst->B = ((src1->B ^ src2->B) >> 1) + (src1->B & src2->B); dst->blue = gl::float16ToFloat32(src->B);
dst->A = ((src1->A ^ src2->A) >> 1) + (src1->A & src2->A); dst->alpha = gl::float16ToFloat32(src->A);
} }
};
struct R32 static void writeColor(R16G16B16A16F *dst, const gl::ColorF *src)
{ {
unsigned int R; dst->R = gl::float32ToFloat16(src->red);
dst->G = gl::float32ToFloat16(src->green);
dst->B = gl::float32ToFloat16(src->blue);
dst->A = gl::float32ToFloat16(src->alpha);
}
static void average(R32 *dst, const R32 *src1, const R32 *src2) static void average(R16G16B16A16F *dst, const R16G16B16A16F *src1, const R16G16B16A16F *src2)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); dst->R = gl::averageHalfFloat(src1->R, src2->R);
dst->G = gl::averageHalfFloat(src1->G, src2->G);
dst->B = gl::averageHalfFloat(src1->B, src2->B);
dst->A = gl::averageHalfFloat(src1->A, src2->A);
} }
}; };
struct R32G32 struct R16F
{ {
unsigned int R; unsigned short R;
unsigned int G;
static void average(R32G32 *dst, const R32G32 *src1, const R32G32 *src2) static void readColor(gl::ColorF *dst, const R16F *src)
{
dst->red = gl::float16ToFloat32(src->R);
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void writeColor(R16F *dst, const gl::ColorF *src)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); dst->R = gl::float32ToFloat16(src->red);
dst->G = ((src1->G ^ src2->G) >> 1) + (src1->G & src2->G); }
static void average(R16F *dst, const R16F *src1, const R16F *src2)
{
dst->R = gl::averageHalfFloat(src1->R, src2->R);
} }
}; };
struct R32G32B32 struct A16F
{ {
unsigned int R; unsigned short A;
unsigned int G;
unsigned int B;
static void average(R32G32B32 *dst, const R32G32B32 *src1, const R32G32B32 *src2) static void readColor(gl::ColorF *dst, const A16F *src)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); dst->red = 0.0f;
dst->G = ((src1->G ^ src2->G) >> 1) + (src1->G & src2->G); dst->green = 0.0f;
dst->B = ((src1->B ^ src2->B) >> 1) + (src1->B & src2->B); dst->blue = 0.0f;
dst->alpha = gl::float16ToFloat32(src->A);
} }
};
struct R32G32B32A32 static void writeColor(A16F *dst, const gl::ColorF *src)
{ {
unsigned int R; dst->A = gl::float32ToFloat16(src->alpha);
unsigned int G; }
unsigned int B;
unsigned int A;
static void average(R32G32B32A32 *dst, const R32G32B32A32 *src1, const R32G32B32A32 *src2) static void average(A16F *dst, const A16F *src1, const A16F *src2)
{ {
dst->R = ((src1->R ^ src2->R) >> 1) + (src1->R & src2->R); dst->A = gl::averageHalfFloat(src1->A, src2->A);
dst->G = ((src1->G ^ src2->G) >> 1) + (src1->G & src2->G);
dst->B = ((src1->B ^ src2->B) >> 1) + (src1->B & src2->B);
dst->A = ((src1->A ^ src2->A) >> 1) + (src1->A & src2->A);
} }
}; };
struct R8S struct L16F
{ {
char R; unsigned short L;
static void average(R8S *dst, const R8S *src1, const R8S *src2) static void readColor(gl::ColorF *dst, const L16F *src)
{ {
dst->R = ((short)src1->R + (short)src2->R) / 2; float lum = gl::float16ToFloat32(src->L);
dst->red = lum;
dst->green = lum;
dst->blue = lum;
dst->alpha = 1.0f;
} }
};
struct R8G8S static void writeColor(L16F *dst, const gl::ColorF *src)
{ {
char R; dst->L = gl::float32ToFloat16((src->red + src->green + src->blue) / 3.0f);
char G; }
static void average(R8G8S *dst, const R8G8S *src1, const R8G8S *src2) static void average(L16F *dst, const L16F *src1, const L16F *src2)
{ {
dst->R = ((short)src1->R + (short)src2->R) / 2; dst->L = gl::averageHalfFloat(src1->L, src2->L);
dst->G = ((short)src1->G + (short)src2->G) / 2;
} }
}; };
struct R8G8B8A8S struct L16A16F
{ {
char R; unsigned short L;
char G; unsigned short A;
char B;
char A;
static void average(R8G8B8A8S *dst, const R8G8B8A8S *src1, const R8G8B8A8S *src2) static void readColor(gl::ColorF *dst, const L16A16F *src)
{ {
dst->R = ((short)src1->R + (short)src2->R) / 2; float lum = gl::float16ToFloat32(src->L);
dst->G = ((short)src1->G + (short)src2->G) / 2; dst->red = lum;
dst->B = ((short)src1->B + (short)src2->B) / 2; dst->green = lum;
dst->A = ((short)src1->A + (short)src2->A) / 2; dst->blue = lum;
dst->alpha = gl::float16ToFloat32(src->A);
} }
};
struct R16S static void writeColor(L16A16F *dst, const gl::ColorF *src)
{ {
unsigned short R; dst->L = gl::float32ToFloat16((src->red + src->green + src->blue) / 3.0f);
dst->A = gl::float32ToFloat16(src->alpha);
}
static void average(R16S *dst, const R16S *src1, const R16S *src2) static void average(L16A16F *dst, const L16A16F *src1, const L16A16F *src2)
{ {
dst->R = ((int)src1->R + (int)src2->R) / 2; dst->L = gl::averageHalfFloat(src1->L, src2->L);
dst->A = gl::averageHalfFloat(src1->A, src2->A);
} }
}; };
struct R16G16S struct R16G16F
{ {
unsigned short R; unsigned short R;
unsigned short G; unsigned short G;
static void average(R16G16S *dst, const R16G16S *src1, const R16G16S *src2) static void readColor(gl::ColorF *dst, const R16G16F *src)
{
dst->red = gl::float16ToFloat32(src->R);
dst->green = gl::float16ToFloat32(src->G);
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void writeColor(R16G16F *dst, const gl::ColorF *src)
{
dst->R = gl::float32ToFloat16(src->red);
dst->G = gl::float32ToFloat16(src->green);
}
static void average(R16G16F *dst, const R16G16F *src1, const R16G16F *src2)
{ {
dst->R = ((int)src1->R + (int)src2->R) / 2; dst->R = gl::averageHalfFloat(src1->R, src2->R);
dst->G = ((int)src1->G + (int)src2->G) / 2; dst->G = gl::averageHalfFloat(src1->G, src2->G);
} }
}; };
struct R16G16B16A16S struct R16G16B16F
{ {
unsigned short R; unsigned short R;
unsigned short G; unsigned short G;
unsigned short B; unsigned short B;
unsigned short A;
static void average(R16G16B16A16S *dst, const R16G16B16A16S *src1, const R16G16B16A16S *src2) static void readColor(gl::ColorF *dst, const R16G16B16F *src)
{ {
dst->R = ((int)src1->R + (int)src2->R) / 2; dst->red = gl::float16ToFloat32(src->R);
dst->G = ((int)src1->G + (int)src2->G) / 2; dst->green = gl::float16ToFloat32(src->G);
dst->B = ((int)src1->B + (int)src2->B) / 2; dst->blue = gl::float16ToFloat32(src->B);
dst->A = ((int)src1->A + (int)src2->A) / 2; dst->alpha = 1.0f;
} }
};
struct R32S static void writeColor(R16G16B16F *dst, const gl::ColorF *src)
{ {
unsigned int R; dst->R = gl::float32ToFloat16(src->red);
dst->G = gl::float32ToFloat16(src->green);
dst->B = gl::float32ToFloat16(src->blue);
}
static void average(R32S *dst, const R32S *src1, const R32S *src2) static void average(R16G16B16F *dst, const R16G16B16F *src1, const R16G16B16F *src2)
{ {
dst->R = ((long long)src1->R + (long long)src2->R) / 2; dst->R = gl::averageHalfFloat(src1->R, src2->R);
dst->G = gl::averageHalfFloat(src1->G, src2->G);
dst->B = gl::averageHalfFloat(src1->B, src2->B);
} }
}; };
struct R32G32S struct A32B32G32R32F
{ {
unsigned int R; float A;
unsigned int G; float R;
float G;
float B;
static void average(R32G32S *dst, const R32G32S *src1, const R32G32S *src2) static void readColor(gl::ColorF *dst, const A32B32G32R32F *src)
{ {
dst->R = ((long long)src1->R + (long long)src2->R) / 2; dst->red = src->R;
dst->G = ((long long)src1->G + (long long)src2->G) / 2; dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
} }
};
struct R32G32B32S static void writeColor(A32B32G32R32F *dst, const gl::ColorF *src)
{ {
unsigned int R; dst->R = src->red;
unsigned int G; dst->G = src->green;
unsigned int B; dst->B = src->blue;
dst->A = src->alpha;
}
static void average(R32G32B32S *dst, const R32G32B32S *src1, const R32G32B32S *src2) static void average(A32B32G32R32F *dst, const A32B32G32R32F *src1, const A32B32G32R32F *src2)
{ {
dst->R = ((long long)src1->R + (long long)src2->R) / 2; dst->R = gl::average(src1->R, src2->R);
dst->G = ((long long)src1->G + (long long)src2->G) / 2; dst->G = gl::average(src1->G, src2->G);
dst->B = ((long long)src1->B + (long long)src2->B) / 2; dst->B = gl::average(src1->B, src2->B);
dst->A = gl::average(src1->A, src2->A);
} }
}; };
struct R32G32B32A32S struct R32G32B32A32F
{ {
unsigned int R; float R;
unsigned int G; float G;
unsigned int B; float B;
unsigned int A; float A;
static void average(R32G32B32A32S *dst, const R32G32B32A32S *src1, const R32G32B32A32S *src2) static void readColor(gl::ColorF *dst, const R32G32B32A32F *src)
{ {
dst->R = ((long long)src1->R + (long long)src2->R) / 2; dst->red = src->R;
dst->G = ((long long)src1->G + (long long)src2->G) / 2; dst->green = src->G;
dst->B = ((long long)src1->B + (long long)src2->B) / 2; dst->blue = src->B;
dst->A = ((long long)src1->A + (long long)src2->A) / 2; dst->alpha = src->A;
} }
};
struct A16B16G16R16F static void writeColor(R32G32B32A32F *dst, const gl::ColorF *src)
{ {
unsigned short R; dst->R = src->red;
unsigned short G; dst->G = src->green;
unsigned short B; dst->B = src->blue;
unsigned short A; dst->A = src->alpha;
}
static void average(A16B16G16R16F *dst, const A16B16G16R16F *src1, const A16B16G16R16F *src2) static void average(R32G32B32A32F *dst, const R32G32B32A32F *src1, const R32G32B32A32F *src2)
{ {
dst->R = gl::float32ToFloat16((gl::float16ToFloat32(src1->R) + gl::float16ToFloat32(src2->R)) * 0.5f); dst->R = gl::average(src1->R, src2->R);
dst->G = gl::float32ToFloat16((gl::float16ToFloat32(src1->G) + gl::float16ToFloat32(src2->G)) * 0.5f); dst->G = gl::average(src1->G, src2->G);
dst->B = gl::float32ToFloat16((gl::float16ToFloat32(src1->B) + gl::float16ToFloat32(src2->B)) * 0.5f); dst->B = gl::average(src1->B, src2->B);
dst->A = gl::float32ToFloat16((gl::float16ToFloat32(src1->A) + gl::float16ToFloat32(src2->A)) * 0.5f); dst->A = gl::average(src1->A, src2->A);
} }
}; };
struct R16G16B16A16F struct R32F
{ {
unsigned short R; float R;
unsigned short G;
unsigned short B;
unsigned short A;
static void average(R16G16B16A16F *dst, const R16G16B16A16F *src1, const R16G16B16A16F *src2) static void readColor(gl::ColorF *dst, const R32F *src)
{ {
dst->R = gl::float32ToFloat16((gl::float16ToFloat32(src1->R) + gl::float16ToFloat32(src2->R)) * 0.5f); dst->red = src->R;
dst->G = gl::float32ToFloat16((gl::float16ToFloat32(src1->G) + gl::float16ToFloat32(src2->G)) * 0.5f); dst->green = 0.0f;
dst->B = gl::float32ToFloat16((gl::float16ToFloat32(src1->B) + gl::float16ToFloat32(src2->B)) * 0.5f); dst->blue = 0.0f;
dst->A = gl::float32ToFloat16((gl::float16ToFloat32(src1->A) + gl::float16ToFloat32(src2->A)) * 0.5f); dst->alpha = 1.0f;
} }
};
struct R16F static void writeColor(R32F *dst, const gl::ColorF *src)
{ {
unsigned short R; dst->R = src->red;
}
static void average(R16F *dst, const R16F *src1, const R16F *src2) static void average(R32F *dst, const R32F *src1, const R32F *src2)
{ {
dst->R = gl::float32ToFloat16((gl::float16ToFloat32(src1->R) + gl::float16ToFloat32(src2->R)) * 0.5f); dst->R = gl::average(src1->R, src2->R);
} }
}; };
struct R16G16F struct A32F
{ {
unsigned short R; float A;
unsigned short G;
static void average(R16G16F *dst, const R16G16F *src1, const R16G16F *src2) static void readColor(gl::ColorF *dst, const A32F *src)
{
dst->red = 0.0f;
dst->green = 0.0f;
dst->blue = 0.0f;
dst->alpha = src->A;
}
static void writeColor(A32F *dst, const gl::ColorF *src)
{
dst->A = src->alpha;
}
static void average(A32F *dst, const A32F *src1, const A32F *src2)
{ {
dst->R = gl::float32ToFloat16((gl::float16ToFloat32(src1->R) + gl::float16ToFloat32(src2->R)) * 0.5f); dst->A = gl::average(src1->A, src2->A);
dst->G = gl::float32ToFloat16((gl::float16ToFloat32(src1->G) + gl::float16ToFloat32(src2->G)) * 0.5f);
} }
}; };
struct A32B32G32R32F struct L32F
{ {
float R; float L;
float G;
float B;
float A;
static void average(A32B32G32R32F *dst, const A32B32G32R32F *src1, const A32B32G32R32F *src2) static void readColor(gl::ColorF *dst, const L32F *src)
{
dst->red = src->L;
dst->green = src->L;
dst->blue = src->L;
dst->alpha = 1.0f;
}
static void writeColor(L32F *dst, const gl::ColorF *src)
{
dst->L = (src->red + src->green + src->blue) / 3.0f;
}
static void average(L32F *dst, const L32F *src1, const L32F *src2)
{ {
dst->R = (src1->R + src2->R) * 0.5f; dst->L = gl::average(src1->L, src2->L);
dst->G = (src1->G + src2->G) * 0.5f;
dst->B = (src1->B + src2->B) * 0.5f;
dst->A = (src1->A + src2->A) * 0.5f;
} }
}; };
struct R32G32B32A32F struct L32A32F
{ {
float R; float L;
float G;
float B;
float A; float A;
static void average(R32G32B32A32F *dst, const R32G32B32A32F *src1, const R32G32B32A32F *src2) static void readColor(gl::ColorF *dst, const L32A32F *src)
{ {
dst->R = (src1->R + src2->R) * 0.5f; dst->red = src->L;
dst->G = (src1->G + src2->G) * 0.5f; dst->green = src->L;
dst->B = (src1->B + src2->B) * 0.5f; dst->blue = src->L;
dst->A = (src1->A + src2->A) * 0.5f; dst->alpha = src->A;
} }
};
struct R32F static void writeColor(L32A32F *dst, const gl::ColorF *src)
{ {
float R; dst->L = (src->red + src->green + src->blue) / 3.0f;
dst->A = src->alpha;
}
static void average(R32F *dst, const R32F *src1, const R32F *src2) static void average(L32A32F *dst, const L32A32F *src1, const L32A32F *src2)
{ {
dst->R = (src1->R + src2->R) * 0.5f; dst->L = gl::average(src1->L, src2->L);
dst->A = gl::average(src1->A, src2->A);
} }
}; };
...@@ -423,10 +1817,24 @@ struct R32G32F ...@@ -423,10 +1817,24 @@ struct R32G32F
float R; float R;
float G; float G;
static void readColor(gl::ColorF *dst, const R32G32F *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = 0.0f;
dst->alpha = 1.0f;
}
static void writeColor(R32G32F *dst, const gl::ColorF *src)
{
dst->R = src->red;
dst->G = src->green;
}
static void average(R32G32F *dst, const R32G32F *src1, const R32G32F *src2) static void average(R32G32F *dst, const R32G32F *src1, const R32G32F *src2)
{ {
dst->R = (src1->R + src2->R) * 0.5f; dst->R = gl::average(src1->R, src2->R);
dst->G = (src1->G + src2->G) * 0.5f; dst->G = gl::average(src1->G, src2->G);
} }
}; };
...@@ -436,11 +1844,26 @@ struct R32G32B32F ...@@ -436,11 +1844,26 @@ struct R32G32B32F
float G; float G;
float B; float B;
static void readColor(gl::ColorF *dst, const R32G32B32F *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = 1.0f;
}
static void writeColor(R32G32B32F *dst, const gl::ColorF *src)
{
dst->R = src->red;
dst->G = src->green;
dst->B = src->blue;
}
static void average(R32G32B32F *dst, const R32G32B32F *src1, const R32G32B32F *src2) static void average(R32G32B32F *dst, const R32G32B32F *src1, const R32G32B32F *src2)
{ {
dst->R = (src1->R + src2->R) * 0.5f; dst->R = gl::average(src1->R, src2->R);
dst->G = (src1->G + src2->G) * 0.5f; dst->G = gl::average(src1->G, src2->G);
dst->B = (src1->B + src2->B) * 0.5f; dst->B = gl::average(src1->B, src2->B);
} }
}; };
...@@ -451,12 +1874,44 @@ struct R10G10B10A2 ...@@ -451,12 +1874,44 @@ struct R10G10B10A2
unsigned int B : 10; unsigned int B : 10;
unsigned int A : 2; unsigned int A : 2;
static void readColor(gl::ColorF *dst, const R10G10B10A2 *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);
}
static void readColor(gl::ColorUI *dst, const R10G10B10A2 *src)
{
dst->red = src->R;
dst->green = src->G;
dst->blue = src->B;
dst->alpha = src->A;
}
static void writeColor(R10G10B10A2 *dst, const gl::ColorF *src)
{
dst->R = gl::floatToNormalized<10, unsigned int>(src->red);
dst->G = gl::floatToNormalized<10, unsigned int>(src->green);
dst->B = gl::floatToNormalized<10, unsigned int>(src->blue);
dst->A = gl::floatToNormalized< 2, unsigned int>(src->alpha);
}
static void writeColor(R10G10B10A2 *dst, const gl::ColorUI *src)
{
dst->R = static_cast<unsigned int>(src->red);
dst->G = static_cast<unsigned int>(src->green);
dst->B = static_cast<unsigned int>(src->blue);
dst->A = static_cast<unsigned int>(src->alpha);
}
static void average(R10G10B10A2 *dst, const R10G10B10A2 *src1, const R10G10B10A2 *src2) static void average(R10G10B10A2 *dst, const R10G10B10A2 *src1, const R10G10B10A2 *src2)
{ {
dst->R = (src1->R + src2->R) >> 1; dst->R = gl::average(src1->R, src2->R);
dst->G = (src1->G + src2->G) >> 1; dst->G = gl::average(src1->G, src2->G);
dst->B = (src1->B + src2->B) >> 1; dst->B = gl::average(src1->B, src2->B);
dst->A = (src1->A + src2->A) >> 1; dst->A = gl::average(src1->A, src2->A);
} }
}; };
...@@ -467,6 +1922,19 @@ struct R9G9B9E5 ...@@ -467,6 +1922,19 @@ struct R9G9B9E5
unsigned int B : 9; unsigned int B : 9;
unsigned int E : 5; unsigned int E : 5;
static void readColor(gl::ColorF *dst, const R9G9B9E5 *src)
{
gl::convert999E5toRGBFloats(gl::bitCast<unsigned int>(*src), &dst->red, &dst->green, &dst->blue);
dst->alpha = 1.0f;
}
static void writeColor(R9G9B9E5 *dst, const gl::ColorF *src)
{
*reinterpret_cast<unsigned int*>(dst) = gl::convertRGBFloatsTo999E5(src->red,
src->green,
src->blue);
}
static void average(R9G9B9E5 *dst, const R9G9B9E5 *src1, const R9G9B9E5 *src2) static void average(R9G9B9E5 *dst, const R9G9B9E5 *src1, const R9G9B9E5 *src2)
{ {
float r1, g1, b1; float r1, g1, b1;
...@@ -475,7 +1943,9 @@ struct R9G9B9E5 ...@@ -475,7 +1943,9 @@ struct R9G9B9E5
float r2, g2, b2; float r2, g2, b2;
gl::convert999E5toRGBFloats(*reinterpret_cast<const unsigned int*>(src2), &r2, &g2, &b2); gl::convert999E5toRGBFloats(*reinterpret_cast<const unsigned int*>(src2), &r2, &g2, &b2);
*reinterpret_cast<unsigned int*>(dst) = gl::convertRGBFloatsTo999E5((r1 + r2) * 0.5f, (g1 + g2) * 0.5f, (b1 + b2) * 0.5f); *reinterpret_cast<unsigned int*>(dst) = gl::convertRGBFloatsTo999E5(gl::average(r1, r2),
gl::average(g1, g2),
gl::average(b1, b2));
} }
}; };
...@@ -485,11 +1955,26 @@ struct R11G11B10F ...@@ -485,11 +1955,26 @@ struct R11G11B10F
unsigned int G : 11; unsigned int G : 11;
unsigned int B : 10; unsigned int B : 10;
static void 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;
}
static void 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);
}
static void average(R11G11B10F *dst, const R11G11B10F *src1, const R11G11B10F *src2) static void average(R11G11B10F *dst, const R11G11B10F *src1, const R11G11B10F *src2)
{ {
dst->R = gl::float32ToFloat11((gl::float11ToFloat32(src1->R) + gl::float11ToFloat32(src2->R)) * 0.5f); dst->R = gl::averageFloat11(src1->R, src2->R);
dst->G = gl::float32ToFloat11((gl::float11ToFloat32(src1->G) + gl::float11ToFloat32(src2->G)) * 0.5f); dst->G = gl::averageFloat11(src1->G, src2->G);
dst->B = gl::float32ToFloat10((gl::float10ToFloat32(src1->B) + gl::float10ToFloat32(src2->B)) * 0.5f); dst->B = gl::averageFloat10(src1->B, src2->B);
} }
}; };
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment