Skip to content

S
swiftshader
Commit 92ac42fa by Alexis Hetu Committed by Alexis Hétu
Options

Texture load functionality for integer types

- Added cases required to load integer type textures into swiftshader's internal formats. - Cleaned up copy functions that simply perform a memcpy for a given number of bytes per row. - Removed unused functionality for mini floats. Right now, all we need is the ability to import these formats, so there's currently no need to keep the export code. Change-Id: I61500c41e668f885d3ec1e687b6f888c117221f2 Reviewed-on: https://swiftshader-review.googlesource.com/4140Tested-by: 's avatarAlexis Hétu <sugoi@google.com> Reviewed-by: 's avatarNicolas Capens <capn@google.com>
parent d3a2d3d7
Showing with 875 additions and 301 deletions
src/Common/Math.hpp
......@@ -346,211 +346,28 @@ namespace sw
class RGB9E5Data
{
union
{
struct
{
unsigned int R : 9;
unsigned int G : 9;
unsigned int B : 9;
unsigned int E : 5;
};
unsigned int uint;
};
// Exponent Bias
static const int Bias = 15;
// Number of mantissa bits per component
static const int MantissaBits = 9;
unsigned int R : 9;
unsigned int G : 9;
unsigned int B : 9;
unsigned int E : 5;
public:
RGB9E5Data(float red, float green, float blue)
{
// Maximum allowed biased exponent value
static const int MaxExponent = 31;
static const float MaxValue = ((pow(2.0f, MantissaBits) - 1) / pow(2.0f, MantissaBits)) * pow(2.0f, MaxExponent - Bias);
const float red_c = sw::max(0.0f, sw::min(MaxValue, red));
const float green_c = sw::max(0.0f, sw::min(MaxValue, green));
const float blue_c = sw::max(0.0f, sw::min(MaxValue, blue));
const float max_c = sw::max(sw::max(red_c, green_c), blue_c);
const float exp_p = sw::max(-Bias - 1.0f, floorf(log(max_c))) + 1.0f + Bias;
const int max_s = static_cast<int>(floor((max_c / (pow(2.0f, exp_p - Bias - MantissaBits))) + 0.5f));
const int exp_s = static_cast<int>((max_s < pow(2.0f, MantissaBits)) ? exp_p : exp_p + 1);
R = static_cast<unsigned int>(floor((red_c / (pow(2.0f, exp_s - Bias - MantissaBits))) + 0.5f));
G = static_cast<unsigned int>(floor((green_c / (pow(2.0f, exp_s - Bias - MantissaBits))) + 0.5f));
B = static_cast<unsigned int>(floor((blue_c / (pow(2.0f, exp_s - Bias - MantissaBits))) + 0.5f));
E = exp_s;
}
void toRGBFloats(float *red, float *green, float *blue) const
void toRGBFloats(float* rgb) const
{
*red = R * pow(2.0f, (int)E - Bias - MantissaBits);
*green = G * pow(2.0f, (int)E - Bias - MantissaBits);
*blue = B * pow(2.0f, (int)E - Bias - MantissaBits);
}
static const float Offset = -24.0f; // Exponent Bias (15) + Number of mantissa bits per component (9) = 24
unsigned int toUInt() const
{
return uint;
const float factor = powf(2.0f, static_cast<float>(E) + Offset);
rgb[0] = static_cast<float>(R) * factor;
rgb[1] = static_cast<float>(G) * factor;
rgb[2] = static_cast<float>(B) * factor;
}
};
class R11G11B10FData
{
union
{
struct
{
unsigned int R : 11;
unsigned int G : 11;
unsigned int B : 10;
};
unsigned int uint;
};
static inline unsigned short float32ToFloat11(float fp32)
{
const unsigned int float32MantissaMask = 0x7FFFFF;
const unsigned int float32ExponentMask = 0x7F800000;
const unsigned int float32SignMask = 0x80000000;
const unsigned int float32ValueMask = ~float32SignMask;
const unsigned int float32ExponentFirstBit = 23;
const unsigned int float32ExponentBias = 127;
const unsigned short float11Max = 0x7BF;
const unsigned short float11MantissaMask = 0x3F;
const unsigned short float11ExponentMask = 0x7C0;
const unsigned short float11BitMask = 0x7FF;
const unsigned int float11ExponentBias = 14;
const unsigned int float32Maxfloat11 = 0x477E0000;
const unsigned int float32Minfloat11 = 0x38800000;
const unsigned int float32Bits = *(unsigned int*)(&fp32);
const bool float32Sign = (float32Bits & float32SignMask) == float32SignMask;
unsigned int float32Val = float32Bits & float32ValueMask;
if((float32Val & float32ExponentMask) == float32ExponentMask)
{
// INF or NAN
if((float32Val & float32MantissaMask) != 0)
{
return float11ExponentMask | (((float32Val >> 17) | (float32Val >> 11) | (float32Val >> 6) | (float32Val)) & float11MantissaMask);
}
else if(float32Sign)
{
// -INF is clamped to 0 since float11 is positive only
return 0;
}
else
{
return float11ExponentMask;
}
}
else if(float32Sign)
{
// float11 is positive only, so clamp to zero
return 0;
}
else if(float32Val > float32Maxfloat11)
{
// The number is too large to be represented as a float11, set to max
return float11Max;
}
else
{
if(float32Val < float32Minfloat11)
{
// The number is too small to be represented as a normalized float11
// Convert it to a denormalized value.
const unsigned int shift = (float32ExponentBias - float11ExponentBias) - (float32Val >> float32ExponentFirstBit);
float32Val = ((1 << float32ExponentFirstBit) | (float32Val & float32MantissaMask)) >> shift;
}
else
{
// Rebias the exponent to represent the value as a normalized float11
float32Val += 0xC8000000;
}
return ((float32Val + 0xFFFF + ((float32Val >> 17) & 1)) >> 17) & float11BitMask;
}
}
static inline unsigned short float32ToFloat10(float fp32)
{
const unsigned int float32MantissaMask = 0x7FFFFF;
const unsigned int float32ExponentMask = 0x7F800000;
const unsigned int float32SignMask = 0x80000000;
const unsigned int float32ValueMask = ~float32SignMask;
const unsigned int float32ExponentFirstBit = 23;
const unsigned int float32ExponentBias = 127;
const unsigned short float10Max = 0x3DF;
const unsigned short float10MantissaMask = 0x1F;
const unsigned short float10ExponentMask = 0x3E0;
const unsigned short float10BitMask = 0x3FF;
const unsigned int float10ExponentBias = 14;
const unsigned int float32Maxfloat10 = 0x477C0000;
const unsigned int float32Minfloat10 = 0x38800000;
const unsigned int float32Bits = *(unsigned int*)(&fp32);
const bool float32Sign = (float32Bits & float32SignMask) == float32SignMask;
unsigned int float32Val = float32Bits & float32ValueMask;
if((float32Val & float32ExponentMask) == float32ExponentMask)
{
// INF or NAN
if((float32Val & float32MantissaMask) != 0)
{
return float10ExponentMask | (((float32Val >> 18) | (float32Val >> 13) | (float32Val >> 3) | (float32Val)) & float10MantissaMask);
}
else if(float32Sign)
{
// -INF is clamped to 0 since float11 is positive only
return 0;
}
else
{
return float10ExponentMask;
}
}
else if(float32Sign)
{
// float10 is positive only, so clamp to zero
return 0;
}
else if(float32Val > float32Maxfloat10)
{
// The number is too large to be represented as a float11, set to max
return float10Max;
}
else
{
if(float32Val < float32Minfloat10)
{
// The number is too small to be represented as a normalized float11
// Convert it to a denormalized value.
const unsigned int shift = (float32ExponentBias - float10ExponentBias) - (float32Val >> float32ExponentFirstBit);
float32Val = ((1 << float32ExponentFirstBit) | (float32Val & float32MantissaMask)) >> shift;
}
else
{
// Rebias the exponent to represent the value as a normalized float11
float32Val += 0xC8000000;
}
return ((float32Val + 0x1FFFF + ((float32Val >> 18) & 1)) >> 18) & float10BitMask;
}
}
unsigned int R : 11;
unsigned int G : 11;
unsigned int B : 10;
static inline float float11ToFloat32(unsigned short fp11)
{
......@@ -635,23 +452,11 @@ namespace sw
}
public:
R11G11B10FData(float r, float g, float b)
{
R = float32ToFloat11(r);
G = float32ToFloat11(g);
B = float32ToFloat10(b);
}
void toRGBFloats(float *red, float *green, float *blue) const
{
*red = float11ToFloat32(R);
*green = float11ToFloat32(G);
*blue = float10ToFloat32(B);
}
unsigned int toUInt() const
void toRGBFloats(float* rgb) const
{
return uint;
rgb[0] = float11ToFloat32(R);
rgb[1] = float11ToFloat32(G);
rgb[2] = float10ToFloat32(B);
}
};
}
......
src/OpenGL/common/Image.cpp
......@@ -14,6 +14,7 @@
#include "Renderer/Blitter.hpp"
#include "../libEGL/Texture.hpp"
#include "../common/debug.h"
#include "Common/Math.hpp"
#include "Common/Thread.hpp"
#include <GLES/glext.h>
......@@ -31,28 +32,39 @@ namespace
enum DataType
{
Alpha,
Bytes_1,
Bytes_2,
Bytes_4,
Bytes_8,
Bytes_16,
AlphaFloat,
AlphaHalfFloat,
Luminance,
LuminanceFloat,
LuminanceHalfFloat,
LuminanceAlpha,
LuminanceAlphaFloat,
LuminanceAlphaHalfFloat,
ByteRGB,
UByteRGB,
ShortRGB,
UShortRGB,
IntRGB,
UIntRGB,
RGB565,
FloatRGB,
HalfFloatRGB,
UByte4,
RGBA4444,
RGBA5551,
Float4,
HalfFloat4,
RGB10A2UI,
R11G11B10F,
RGB9E5,
SRGB,
SRGBA,
D16,
D24,
D32,
D32F,
S8,
S24_8,
};
template<DataType dataType>
......@@ -62,12 +74,36 @@ namespace
}
template<>
void LoadImageRow<Alpha>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
void LoadImageRow<Bytes_1>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset, source, width);
}
template<>
void LoadImageRow<Bytes_2>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 2, source, width * 2);
}
template<>
void LoadImageRow<Bytes_4>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 4, source, width * 4);
}
template<>
void LoadImageRow<Bytes_8>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 8, source, width * 8);
}
template<>
void LoadImageRow<Bytes_16>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 16, source, width * 16);
}
template<>
void LoadImageRow<AlphaFloat>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const float *sourceF = reinterpret_cast<const float*>(source);
......@@ -98,12 +134,6 @@ namespace
}
template<>
void LoadImageRow<Luminance>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset, source, width);
}
template<>
void LoadImageRow<LuminanceFloat>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const float *sourceF = reinterpret_cast<const float*>(source);
......@@ -134,12 +164,6 @@ namespace
}
template<>
void LoadImageRow<LuminanceAlpha>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 2, source, width * 2);
}
template<>
void LoadImageRow<LuminanceAlphaFloat>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const float *sourceF = reinterpret_cast<const float*>(source);
......@@ -170,6 +194,20 @@ namespace
}
template<>
void LoadImageRow<ByteRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
unsigned char *destB = dest + xoffset * 4;
for(int x = 0; x < width; x++)
{
destB[4 * x + 0] = source[x * 3 + 0];
destB[4 * x + 1] = source[x * 3 + 1];
destB[4 * x + 2] = source[x * 3 + 2];
destB[4 * x + 3] = 0x7F;
}
}
template<>
void LoadImageRow<UByteRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
unsigned char *destB = dest + xoffset * 4;
......@@ -184,6 +222,66 @@ namespace
}
template<>
void LoadImageRow<ShortRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const unsigned short *sourceS = reinterpret_cast<const unsigned short*>(source);
unsigned short *destS = reinterpret_cast<unsigned short*>(dest + xoffset * 8);
for(int x = 0; x < width; x++)
{
destS[4 * x + 0] = sourceS[x * 3 + 0];
destS[4 * x + 1] = sourceS[x * 3 + 1];
destS[4 * x + 2] = sourceS[x * 3 + 2];
destS[4 * x + 3] = 0x7FFF;
}
}
template<>
void LoadImageRow<UShortRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const unsigned short *sourceS = reinterpret_cast<const unsigned short*>(source);
unsigned short *destS = reinterpret_cast<unsigned short*>(dest + xoffset * 8);
for(int x = 0; x < width; x++)
{
destS[4 * x + 0] = sourceS[x * 3 + 0];
destS[4 * x + 1] = sourceS[x * 3 + 1];
destS[4 * x + 2] = sourceS[x * 3 + 2];
destS[4 * x + 3] = 0xFFFF;
}
}
template<>
void LoadImageRow<IntRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source);
unsigned int *destI = reinterpret_cast<unsigned int*>(dest + xoffset * 16);
for(int x = 0; x < width; x++)
{
destI[4 * x + 0] = sourceI[x * 3 + 0];
destI[4 * x + 1] = sourceI[x * 3 + 1];
destI[4 * x + 2] = sourceI[x * 3 + 2];
destI[4 * x + 3] = 0x7FFFFFFF;
}
}
template<>
void LoadImageRow<UIntRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source);
unsigned int *destI = reinterpret_cast<unsigned int*>(dest + xoffset * 16);
for(int x = 0; x < width; x++)
{
destI[4 * x + 0] = sourceI[x * 3 + 0];
destI[4 * x + 1] = sourceI[x * 3 + 1];
destI[4 * x + 2] = sourceI[x * 3 + 2];
destI[4 * x + 3] = 0xFFFFFFFF;
}
}
template<>
void LoadImageRow<RGB565>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 2, source, width * 2);
......@@ -220,12 +318,6 @@ namespace
}
template<>
void LoadImageRow<UByte4>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 4, source, width * 4);
}
template<>
void LoadImageRow<RGBA4444>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const unsigned short *source4444 = reinterpret_cast<const unsigned short*>(source);
......@@ -258,15 +350,75 @@ namespace
}
template<>
void LoadImageRow<Float4>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
void LoadImageRow<RGB10A2UI>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 16, source, width * 16);
const unsigned int *source1010102U = reinterpret_cast<const unsigned int*>(source);
unsigned short *dest16U = reinterpret_cast<unsigned short*>(dest + xoffset * 8);
for(int x = 0; x < width; x++)
{
unsigned int rgba = source1010102U[x];
dest16U[4 * x + 0] = (rgba & 0x00000FFC) >> 2;
dest16U[4 * x + 1] = (rgba & 0x003FF000) >> 12;
dest16U[4 * x + 2] = (rgba & 0xFFC00000) >> 22;
dest16U[4 * x + 3] = (rgba & 0x00000003);
}
}
template<>
void LoadImageRow<HalfFloat4>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
void LoadImageRow<R11G11B10F>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
memcpy(dest + xoffset * 8, source, width * 8);
const sw::R11G11B10FData *sourceRGB = reinterpret_cast<const sw::R11G11B10FData*>(source);
float *destF = reinterpret_cast<float*>(dest + xoffset * 16);
for(int x = 0; x < width; x++, sourceRGB++, destF+=4)
{
sourceRGB->toRGBFloats(destF);
destF[3] = 1.0f;
}
}
template<>
void LoadImageRow<RGB9E5>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
const sw::RGB9E5Data *sourceRGB = reinterpret_cast<const sw::RGB9E5Data*>(source);
float *destF = reinterpret_cast<float*>(dest + xoffset * 16);
for(int x = 0; x < width; x++, sourceRGB++, destF += 4)
{
sourceRGB->toRGBFloats(destF);
destF[3] = 1.0f;
}
}
template<>
void LoadImageRow<SRGB>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
dest += xoffset * 4;
for(int x = 0; x < width; x++)
{
for(int rgb = 0; rgb < 3; ++rgb)
{
*dest++ = sw::sRGB8toLinear8(*source++);
}
*dest++ = 255;
}
}
template<>
void LoadImageRow<SRGBA>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
dest += xoffset * 4;
for(int x = 0; x < width; x++)
{
for(int rgb = 0; rgb < 3; ++rgb)
{
*dest++ = sw::sRGB8toLinear8(*source++);
}
*dest++ = *source++;
}
}
template<>
......@@ -317,6 +469,32 @@ namespace
}
}
template<>
void LoadImageRow<D32F>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
struct D32FS8 { float depth32f; unsigned int stencil24_8; };
const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source);
float *destF = reinterpret_cast<float*>(dest + xoffset * 4);
for(int x = 0; x < width; x++)
{
destF[x] = sourceD32FS8[x].depth32f;
}
}
template<>
void LoadImageRow<S24_8>(const unsigned char *source, unsigned char *dest, GLint xoffset, GLsizei width)
{
struct D32FS8 { float depth32f; unsigned int stencil24_8; };
const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source);
unsigned char *destI = dest + xoffset;
for(int x = 0; x < width; x++)
{
destI[x] = static_cast<unsigned char>(sourceD32FS8[x].stencil24_8 & 0x000000FF); // FIXME: Quad layout
}
}
template<DataType dataType>
void LoadImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, int destPitch, GLsizei destHeight, const void *input, void *buffer)
{
......@@ -351,6 +529,12 @@ namespace egl
default: UNREACHABLE(type);
}
break;
case GL_LUMINANCE8_EXT:
return sw::FORMAT_L8;
case GL_LUMINANCE16F_EXT:
return sw::FORMAT_L16F;
case GL_LUMINANCE32F_EXT:
return sw::FORMAT_L32F;
case GL_LUMINANCE_ALPHA:
switch(type)
{
......@@ -361,6 +545,12 @@ namespace egl
default: UNREACHABLE(type);
}
break;
case GL_LUMINANCE8_ALPHA8_EXT:
return sw::FORMAT_A8L8;
case GL_LUMINANCE_ALPHA16F_EXT:
return sw::FORMAT_A16L16F;
case GL_LUMINANCE_ALPHA32F_EXT:
return sw::FORMAT_A32L32F;
case GL_RGBA:
switch(type)
{
......@@ -401,6 +591,12 @@ namespace egl
default: UNREACHABLE(type);
}
break;
case GL_ALPHA8_EXT:
return sw::FORMAT_A8;
case GL_ALPHA16F_EXT:
return sw::FORMAT_A16F;
case GL_ALPHA32F_EXT:
return sw::FORMAT_A32F;
default:
UNREACHABLE(format);
}
......@@ -503,85 +699,248 @@ namespace egl
break;
}
if(type == GL_FLOAT)
{
return sw::FORMAT_A32B32G32R32F;
}
else if(type == GL_HALF_FLOAT || type == GL_HALF_FLOAT_OES)
{
return sw::FORMAT_A16B16G16R16F;
}
else if(type == GL_UNSIGNED_BYTE)
switch(type)
{
if(format == GL_LUMINANCE)
{
return sw::FORMAT_L8;
}
else if(format == GL_LUMINANCE_ALPHA)
case GL_FLOAT:
switch(format)
{
return sw::FORMAT_A8L8;
case GL_RED:
case GL_R32F:
return sw::FORMAT_R32F;
case GL_RG:
case GL_RG32F:
return sw::FORMAT_G32R32F;
case GL_RGB:
case GL_RGB32F:
case GL_RGBA:
case GL_RGBA32F:
return sw::FORMAT_A32B32G32R32F;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT32F:
return sw::FORMAT_D32F;
default:
UNREACHABLE(format);
}
else if(format == GL_RGBA)
case GL_HALF_FLOAT:
case GL_HALF_FLOAT_OES:
switch(format)
{
return sw::FORMAT_A8B8G8R8;
case GL_RED:
case GL_R16F:
return sw::FORMAT_R16F;
case GL_RG:
case GL_RG16F:
return sw::FORMAT_G16R16F;
case GL_RGB:
case GL_RGB16F:
case GL_RGBA:
case GL_RGBA16F:
return sw::FORMAT_A16B16G16R16F;
default:
UNREACHABLE(format);
}
else if(format == GL_BGRA_EXT)
case GL_BYTE:
switch(format)
{
return sw::FORMAT_A8R8G8B8;
case GL_R8_SNORM:
case GL_R8:
case GL_RED:
return sw::FORMAT_R8I_SNORM;
case GL_R8I:
case GL_RED_INTEGER:
return sw::FORMAT_R8I;
case GL_RG8_SNORM:
case GL_RG8:
case GL_RG:
return sw::FORMAT_G8R8I_SNORM;
case GL_RG8I:
case GL_RG_INTEGER:
return sw::FORMAT_G8R8I;
case GL_RGB8_SNORM:
case GL_RGB8:
case GL_RGB:
return sw::FORMAT_X8B8G8R8I_SNORM;
case GL_RGB8I:
case GL_RGB_INTEGER:
return sw::FORMAT_X8B8G8R8I;
case GL_RGBA8_SNORM:
case GL_RGBA8:
case GL_RGBA:
return sw::FORMAT_A8B8G8R8I_SNORM;
case GL_RGBA8I:
case GL_RGBA_INTEGER:
return sw::FORMAT_A8B8G8R8I;
default:
UNREACHABLE(format);
}
else if(format == GL_RGB)
case GL_UNSIGNED_BYTE:
switch(format)
{
case GL_LUMINANCE:
case GL_LUMINANCE8_EXT:
return sw::FORMAT_L8;
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE8_ALPHA8_EXT:
return sw::FORMAT_A8L8;
case GL_R8_SNORM:
case GL_R8:
case GL_RED:
return sw::FORMAT_R8;
case GL_R8UI:
case GL_RED_INTEGER:
return sw::FORMAT_R8UI;
case GL_RG8_SNORM:
case GL_RG8:
case GL_RG:
return sw::FORMAT_G8R8;
case GL_RG8UI:
case GL_RG_INTEGER:
return sw::FORMAT_G8R8UI;
case GL_RGB8_SNORM:
case GL_RGB8:
case GL_RGB:
case GL_SRGB8:
return sw::FORMAT_X8B8G8R8;
case GL_RGB8UI:
case GL_RGB_INTEGER:
return sw::FORMAT_X8B8G8R8UI;
case GL_RGBA8_SNORM:
case GL_RGBA8:
case GL_RGBA:
case GL_SRGB8_ALPHA8:
return sw::FORMAT_A8B8G8R8;
case GL_RGBA8UI:
case GL_RGBA_INTEGER:
return sw::FORMAT_A8B8G8R8UI;
case GL_BGRA_EXT:
return sw::FORMAT_A8R8G8B8;
case GL_ALPHA:
case GL_ALPHA8_EXT:
return sw::FORMAT_A8;
default:
UNREACHABLE(format);
}
else if(format == GL_ALPHA)
case GL_SHORT:
switch(format)
{
return sw::FORMAT_A8;
case GL_R16I:
case GL_RED_INTEGER:
return sw::FORMAT_R16I;
case GL_RG16I:
case GL_RG_INTEGER:
return sw::FORMAT_G16R16I;
case GL_RGB16I:
case GL_RGB_INTEGER:
return sw::FORMAT_X16B16G16R16I;
case GL_RGBA16I:
case GL_RGBA_INTEGER:
return sw::FORMAT_A16B16G16R16I;
default:
UNREACHABLE(format);
}
else if(format == SW_YV12_BT601)
case GL_UNSIGNED_SHORT:
switch(format)
{
return sw::FORMAT_YV12_BT601;
case GL_R16UI:
case GL_RED_INTEGER:
return sw::FORMAT_R16UI;
case GL_RG16UI:
case GL_RG_INTEGER:
return sw::FORMAT_G16R16UI;
case GL_RGB16UI:
case GL_RGB_INTEGER:
return sw::FORMAT_X16B16G16R16UI;
case GL_RGBA16UI:
case GL_RGBA_INTEGER:
return sw::FORMAT_A16B16G16R16UI;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT16:
return sw::FORMAT_D32FS8_TEXTURE;
default:
UNREACHABLE(format);
}
else if(format == SW_YV12_BT709)
case GL_INT:
switch(format)
{
return sw::FORMAT_YV12_BT709;
case GL_RED_INTEGER:
case GL_R32I:
return sw::FORMAT_R32I;
case GL_RG_INTEGER:
case GL_RG32I:
return sw::FORMAT_G32R32I;
case GL_RGB_INTEGER:
case GL_RGB32I:
return sw::FORMAT_X32B32G32R32I;
case GL_RGBA_INTEGER:
case GL_RGBA32I:
return sw::FORMAT_A32B32G32R32I;
default:
UNREACHABLE(format);
}
else if(format == SW_YV12_JFIF)
case GL_UNSIGNED_INT:
switch(format)
{
return sw::FORMAT_YV12_JFIF;
case GL_RED_INTEGER:
case GL_R32UI:
return sw::FORMAT_R32UI;
case GL_RG_INTEGER:
case GL_RG32UI:
return sw::FORMAT_G32R32UI;
case GL_RGB_INTEGER:
case GL_RGB32UI:
return sw::FORMAT_X32B32G32R32UI;
case GL_RGBA_INTEGER:
case GL_RGBA32UI:
return sw::FORMAT_A32B32G32R32UI;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32_OES:
return sw::FORMAT_D32FS8_TEXTURE;
default:
UNREACHABLE(format);
}
else UNREACHABLE(format);
}
else if(type == GL_UNSIGNED_SHORT || type == GL_UNSIGNED_INT)
{
if(format == GL_DEPTH_COMPONENT)
case GL_UNSIGNED_INT_24_8_OES:
if(format == GL_DEPTH_STENCIL || format == GL_DEPTH24_STENCIL8)
{
return sw::FORMAT_D32FS8_TEXTURE;
}
else UNREACHABLE(format);
}
else if(type == GL_UNSIGNED_INT_24_8_OES)
{
if(format == GL_DEPTH_STENCIL_OES)
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
if(format == GL_DEPTH_STENCIL || format == GL_DEPTH32F_STENCIL8)
{
return sw::FORMAT_D32FS8_TEXTURE;
}
else UNREACHABLE(format);
}
else if(type == GL_UNSIGNED_SHORT_4_4_4_4)
{
case GL_UNSIGNED_SHORT_4_4_4_4:
return sw::FORMAT_A8R8G8B8;
}
else if(type == GL_UNSIGNED_SHORT_5_5_5_1)
{
case GL_UNSIGNED_SHORT_5_5_5_1:
return sw::FORMAT_A8R8G8B8;
}
else if(type == GL_UNSIGNED_SHORT_5_6_5)
{
case GL_UNSIGNED_SHORT_5_6_5:
return sw::FORMAT_R5G6B5;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if(format == GL_RGB10_A2UI)
{
return sw::FORMAT_A16B16G16R16UI;
}
else
{
return sw::FORMAT_A2B10G10R10;
}
case GL_UNSIGNED_INT_10F_11F_11F_REV:
case GL_UNSIGNED_INT_5_9_9_9_REV:
return sw::FORMAT_A32B32G32R32F;
case SW_YV12_BT601:
return sw::FORMAT_YV12_BT601;
case SW_YV12_BT709:
return sw::FORMAT_YV12_BT709;
case SW_YV12_JFIF:
return sw::FORMAT_YV12_JFIF;
default:
UNREACHABLE(type);
}
else UNREACHABLE(type);
return sw::FORMAT_A8B8G8R8;
return sw::FORMAT_NULL;
}
// Returns the size, in bytes, of a single texel in an Image
......@@ -589,34 +948,155 @@ namespace egl
{
switch(type)
{
case GL_BYTE:
switch(format)
{
case GL_R8:
case GL_R8I:
case GL_R8_SNORM:
case GL_RED: return sizeof(char);
case GL_RED_INTEGER: return sizeof(char);
case GL_RG8:
case GL_RG8I:
case GL_RG8_SNORM:
case GL_RG: return sizeof(char) * 2;
case GL_RG_INTEGER: return sizeof(char) * 2;
case GL_RGB8:
case GL_RGB8I:
case GL_RGB8_SNORM:
case GL_RGB: return sizeof(char) * 3;
case GL_RGB_INTEGER: return sizeof(char) * 3;
case GL_RGBA8:
case GL_RGBA8I:
case GL_RGBA8_SNORM:
case GL_RGBA: return sizeof(char) * 4;
case GL_RGBA_INTEGER: return sizeof(char) * 4;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_BYTE:
switch(format)
{
case GL_R8:
case GL_R8UI:
case GL_RED: return sizeof(unsigned char);
case GL_RED_INTEGER: return sizeof(unsigned char);
case GL_ALPHA8_EXT:
case GL_ALPHA: return sizeof(unsigned char);
case GL_LUMINANCE8_EXT:
case GL_LUMINANCE: return sizeof(unsigned char);
case GL_LUMINANCE8_ALPHA8_EXT:
case GL_LUMINANCE_ALPHA: return sizeof(unsigned char) * 2;
case GL_RG8:
case GL_RG8UI:
case GL_RG: return sizeof(unsigned char) * 2;
case GL_RG_INTEGER: return sizeof(unsigned char) * 2;
case GL_RGB8:
case GL_RGB8UI:
case GL_SRGB8:
case GL_RGB: return sizeof(unsigned char) * 3;
case GL_RGB_INTEGER: return sizeof(unsigned char) * 3;
case GL_RGBA8:
case GL_RGBA8UI:
case GL_SRGB8_ALPHA8:
case GL_RGBA: return sizeof(unsigned char) * 4;
case GL_RGBA_INTEGER: return sizeof(unsigned char) * 4;
case GL_BGRA_EXT: return sizeof(unsigned char) * 4;
default: UNREACHABLE(format);
}
break;
case GL_SHORT:
switch(format)
{
case GL_R16I:
case GL_RED_INTEGER: return sizeof(short);
case GL_RG16I:
case GL_RG_INTEGER: return sizeof(short) * 2;
case GL_RGB16I:
case GL_RGB_INTEGER: return sizeof(short) * 3;
case GL_RGBA16I:
case GL_RGBA_INTEGER: return sizeof(short) * 4;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_SHORT:
switch(format)
{
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT: return sizeof(unsigned short);
case GL_R16UI:
case GL_RED_INTEGER: return sizeof(unsigned short);
case GL_RG16UI:
case GL_RG_INTEGER: return sizeof(unsigned short) * 2;
case GL_RGB16UI:
case GL_RGB_INTEGER: return sizeof(unsigned short) * 3;
case GL_RGBA16UI:
case GL_RGBA_INTEGER: return sizeof(unsigned short) * 4;
default: UNREACHABLE(format);
}
break;
case GL_INT:
switch(format)
{
case GL_R32I:
case GL_RED_INTEGER: return sizeof(int);
case GL_RG32I:
case GL_RG_INTEGER: return sizeof(int) * 2;
case GL_RGB32I:
case GL_RGB_INTEGER: return sizeof(int) * 3;
case GL_RGBA32I:
case GL_RGBA_INTEGER: return sizeof(int) * 4;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_INT:
switch(format)
{
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH_COMPONENT: return sizeof(unsigned int);
case GL_R32UI:
case GL_RED_INTEGER: return sizeof(unsigned int);
case GL_RG32UI:
case GL_RG_INTEGER: return sizeof(unsigned int) * 2;
case GL_RGB32UI:
case GL_RGB_INTEGER: return sizeof(unsigned int) * 3;
case GL_RGBA32UI:
case GL_RGBA_INTEGER: return sizeof(unsigned int) * 4;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT:
return sizeof(unsigned short);
case GL_UNSIGNED_INT:
case GL_UNSIGNED_INT_10F_11F_11F_REV:
case GL_UNSIGNED_INT_5_9_9_9_REV:
case GL_UNSIGNED_INT_2_10_10_10_REV:
case GL_UNSIGNED_INT_24_8_OES:
return sizeof(unsigned int);
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
return sizeof(float) + sizeof(unsigned int);
case GL_FLOAT:
switch(format)
{
case GL_DEPTH_COMPONENT32F:
case GL_DEPTH_COMPONENT: return sizeof(float);
case GL_ALPHA32F_EXT:
case GL_ALPHA: return sizeof(float);
case GL_LUMINANCE32F_EXT:
case GL_LUMINANCE: return sizeof(float);
case GL_LUMINANCE_ALPHA32F_EXT:
case GL_LUMINANCE_ALPHA: return sizeof(float) * 2;
case GL_RED: return sizeof(float);
case GL_R32F: return sizeof(float);
case GL_RG: return sizeof(float) * 2;
case GL_RG32F: return sizeof(float) * 2;
case GL_RGB: return sizeof(float) * 3;
case GL_RGB32F: return sizeof(float) * 3;
case GL_RGBA: return sizeof(float) * 4;
case GL_RGBA32F: return sizeof(float) * 4;
default: UNREACHABLE(format);
}
break;
......@@ -624,11 +1104,20 @@ namespace egl
case GL_HALF_FLOAT_OES:
switch(format)
{
case GL_ALPHA16F_EXT:
case GL_ALPHA: return sizeof(unsigned short);
case GL_LUMINANCE16F_EXT:
case GL_LUMINANCE: return sizeof(unsigned short);
case GL_LUMINANCE_ALPHA16F_EXT:
case GL_LUMINANCE_ALPHA: return sizeof(unsigned short) * 2;
case GL_RED: return sizeof(unsigned short);
case GL_R16F: return sizeof(unsigned short);
case GL_RG: return sizeof(unsigned short) * 2;
case GL_RG16F: return sizeof(unsigned short) * 2;
case GL_RGB: return sizeof(unsigned short) * 3;
case GL_RGB16F: return sizeof(unsigned short) * 3;
case GL_RGBA: return sizeof(unsigned short) * 4;
case GL_RGBA16F: return sizeof(unsigned short) * 4;
default: UNREACHABLE(format);
}
break;
......@@ -765,8 +1254,13 @@ namespace egl
GLsizei inputPitch = ComputePitch((unpackInfo.rowLength == 0) ? width : unpackInfo.rowLength, format, type, unpackInfo.alignment);
GLsizei inputHeight = (unpackInfo.imageHeight == 0) ? height : unpackInfo.imageHeight;
input = ((char*)input) + (unpackInfo.skipImages * inputHeight + unpackInfo.skipRows) * inputPitch + unpackInfo.skipPixels;
sw::Format selectedInternalFormat = SelectInternalFormat(format, type);
if(selectedInternalFormat == sw::FORMAT_NULL)
{
return;
}
if(SelectInternalFormat(format, type) == internalFormat)
if(selectedInternalFormat == internalFormat)
{
void *buffer = lock(0, 0, sw::LOCK_WRITEONLY);
......@@ -774,24 +1268,90 @@ namespace egl
{
switch(type)
{
case GL_UNSIGNED_BYTE:
case GL_BYTE:
switch(format)
{
case GL_R8:
case GL_R8I:
case GL_R8_SNORM:
case GL_RED:
case GL_RED_INTEGER:
case GL_ALPHA:
LoadImageData<Alpha>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
case GL_ALPHA8_EXT:
case GL_LUMINANCE:
case GL_LUMINANCE8_EXT:
LoadImageData<Bytes_1>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG8:
case GL_RG8I:
case GL_RG8_SNORM:
case GL_RG:
case GL_RG_INTEGER:
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE8_ALPHA8_EXT:
LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB8:
case GL_RGB8I:
case GL_RGB8_SNORM:
case GL_RGB:
case GL_RGB_INTEGER:
LoadImageData<ByteRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA8:
case GL_RGBA8I:
case GL_RGBA8_SNORM:
case GL_RGBA:
case GL_RGBA_INTEGER:
case GL_BGRA_EXT:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_BYTE:
switch(format)
{
case GL_R8:
case GL_R8UI:
case GL_R8_SNORM:
case GL_RED:
case GL_RED_INTEGER:
case GL_ALPHA:
case GL_ALPHA8_EXT:
case GL_LUMINANCE:
LoadImageData<Luminance>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
case GL_LUMINANCE8_EXT:
LoadImageData<Bytes_1>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG8:
case GL_RG8UI:
case GL_RG8_SNORM:
case GL_RG:
case GL_RG_INTEGER:
case GL_LUMINANCE_ALPHA:
LoadImageData<LuminanceAlpha>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
case GL_LUMINANCE8_ALPHA8_EXT:
LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB8:
case GL_RGB8UI:
case GL_RGB8_SNORM:
case GL_RGB:
case GL_RGB_INTEGER:
LoadImageData<UByteRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA8:
case GL_RGBA8UI:
case GL_RGBA8_SNORM:
case GL_RGBA:
case GL_RGBA_INTEGER:
case GL_BGRA_EXT:
LoadImageData<UByte4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_SRGB8:
LoadImageData<SRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_SRGB8_ALPHA8:
LoadImageData<SRGBA>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
......@@ -799,6 +1359,7 @@ namespace egl
case GL_UNSIGNED_SHORT_5_6_5:
switch(format)
{
case GL_RGB565:
case GL_RGB:
LoadImageData<RGB565>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
......@@ -808,6 +1369,7 @@ namespace egl
case GL_UNSIGNED_SHORT_4_4_4_4:
switch(format)
{
case GL_RGBA4:
case GL_RGBA:
LoadImageData<RGBA4444>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
......@@ -817,30 +1379,82 @@ namespace egl
case GL_UNSIGNED_SHORT_5_5_5_1:
switch(format)
{
case GL_RGB5_A1:
case GL_RGBA:
LoadImageData<RGBA5551>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_INT_10F_11F_11F_REV:
switch(format)
{
case GL_R11F_G11F_B10F:
case GL_RGB:
LoadImageData<R11G11B10F>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_INT_5_9_9_9_REV:
switch(format)
{
case GL_RGB9_E5:
case GL_RGB:
LoadImageData<RGB9E5>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
switch(format)
{
case GL_RGB10_A2UI:
LoadImageData<RGB10A2UI>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB10_A2:
case GL_RGBA:
case GL_RGBA_INTEGER:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_FLOAT:
switch(format)
{
// float textures are converted to RGBA, not BGRA
case GL_ALPHA:
case GL_ALPHA32F_EXT:
LoadImageData<AlphaFloat>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_LUMINANCE:
case GL_LUMINANCE32F_EXT:
LoadImageData<LuminanceFloat>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE_ALPHA32F_EXT:
LoadImageData<LuminanceAlphaFloat>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RED:
case GL_R32F:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG:
case GL_RG32F:
LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB:
case GL_RGB32F:
LoadImageData<FloatRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA:
LoadImageData<Float4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
case GL_RGBA32F:
LoadImageData<Bytes_16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT32F:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
......@@ -850,32 +1464,172 @@ namespace egl
switch(format)
{
case GL_ALPHA:
case GL_ALPHA16F_EXT:
LoadImageData<AlphaHalfFloat>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_LUMINANCE:
case GL_LUMINANCE16F_EXT:
LoadImageData<LuminanceHalfFloat>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE_ALPHA16F_EXT:
LoadImageData<LuminanceAlphaHalfFloat>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RED:
case GL_R16F:
LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG:
case GL_RG16F:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB:
case GL_RGB16F:
LoadImageData<HalfFloatRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA:
LoadImageData<HalfFloat4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
case GL_RGBA16F:
LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_SHORT:
switch(format)
{
case GL_R16I:
case GL_RED:
case GL_RED_INTEGER:
case GL_ALPHA:
case GL_LUMINANCE:
LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG16I:
case GL_RG:
case GL_RG_INTEGER:
case GL_LUMINANCE_ALPHA:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB16I:
case GL_RGB:
case GL_RGB_INTEGER:
LoadImageData<ShortRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA16I:
case GL_RGBA:
case GL_RGBA_INTEGER:
case GL_BGRA_EXT:
LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_SHORT:
LoadImageData<D16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
switch(format)
{
case GL_R16UI:
case GL_RED:
case GL_RED_INTEGER:
case GL_ALPHA:
case GL_LUMINANCE:
LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG16UI:
case GL_RG:
case GL_RG_INTEGER:
case GL_LUMINANCE_ALPHA:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB16UI:
case GL_RGB:
case GL_RGB_INTEGER:
LoadImageData<UShortRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA16UI:
case GL_RGBA:
case GL_RGBA_INTEGER:
case GL_BGRA_EXT:
LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT16:
LoadImageData<D16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_INT:
switch(format)
{
case GL_R32I:
case GL_RED:
case GL_RED_INTEGER:
case GL_ALPHA:
case GL_LUMINANCE:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG32I:
case GL_RG:
case GL_RG_INTEGER:
case GL_LUMINANCE_ALPHA:
LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB32I:
case GL_RGB:
case GL_RGB_INTEGER:
LoadImageData<IntRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA32I:
case GL_RGBA:
case GL_RGBA_INTEGER:
case GL_BGRA_EXT:
LoadImageData<Bytes_16>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_INT:
LoadImageData<D32>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
switch(format)
{
case GL_R32UI:
case GL_RED:
case GL_RED_INTEGER:
case GL_ALPHA:
case GL_LUMINANCE:
LoadImageData<Bytes_2>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RG32UI:
case GL_RG:
case GL_RG_INTEGER:
case GL_LUMINANCE_ALPHA:
LoadImageData<Bytes_4>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGB32UI:
case GL_RGB:
case GL_RGB_INTEGER:
LoadImageData<UIntRGB>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_RGBA32UI:
case GL_RGBA:
case GL_RGBA_INTEGER:
case GL_BGRA_EXT:
LoadImageData<Bytes_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH_COMPONENT:
LoadImageData<D32>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
break;
default: UNREACHABLE(format);
}
break;
case GL_UNSIGNED_INT_24_8_OES:
loadD24S8ImageData(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, input, buffer);
break;
case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
loadD32FS8ImageData(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, input, buffer);
break;
default: UNREACHABLE(type);
}
}
......@@ -905,6 +1659,20 @@ namespace egl
}
}
void Image::loadD32FS8ImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, const void *input, void *buffer)
{
LoadImageData<D32F>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getPitch(), getHeight(), input, buffer);
unsigned char *stencil = reinterpret_cast<unsigned char*>(lockStencil(0, sw::PUBLIC));
if(stencil)
{
LoadImageData<S24_8>(xoffset, yoffset, zoffset, width, height, depth, inputPitch, inputHeight, getStencilPitchB(), getHeight(), input, stencil);
unlockStencil();
}
}
void Image::loadCompressedData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
{
if(zoffset != 0 || depth != 1)
......
src/OpenGL/common/Image.hpp
......@@ -171,6 +171,7 @@ protected:
virtual ~Image();
void loadD24S8ImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, const void *input, void *buffer);
void loadD32FS8ImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, const void *input, void *buffer);
};
#ifdef __ANDROID__
......
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