#include "Image.hpp"
-#include "../libEGL/Context.hpp"
#include "../libEGL/Texture.hpp"
#include "../common/debug.h"
#include "Common/Math.hpp"
#include <GLES3/gl3.h>
#include <string.h>
+#include <algorithm>
-namespace
+namespace gl
{
- int getNumBlocks(int w, int h, int blockSizeX, int blockSizeY)
- {
- return ((w + blockSizeX - 1) / blockSizeX) * ((h + blockSizeY - 1) / blockSizeY);
- }
-
- enum DataType
- {
- Bytes_1,
- Bytes_2,
- Bytes_4,
- Bytes_8,
- Bytes_16,
- ByteRGB,
- UByteRGB,
- ShortRGB,
- UShortRGB,
- IntRGB,
- UIntRGB,
- FloatRGB,
- HalfFloatRGB,
- RGBA4444,
- RGBA5551,
- R11G11B10F,
- RGB9E5,
- D16,
- D24,
- D32,
- D32F,
- D32FS8,
- S8,
- S24_8,
- };
-
- template<DataType dataType>
- void LoadImageRow(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- UNIMPLEMENTED();
- }
-
- template<>
- void LoadImageRow<Bytes_1>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- memcpy(dest, source, width);
- }
-
- template<>
- void LoadImageRow<Bytes_2>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- memcpy(dest, source, width * 2);
- }
-
- template<>
- void LoadImageRow<Bytes_4>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- memcpy(dest, source, width * 4);
- }
-
- template<>
- void LoadImageRow<Bytes_8>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- memcpy(dest, source, width * 8);
- }
-
- template<>
- void LoadImageRow<Bytes_16>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- memcpy(dest, source, width * 16);
- }
-
- template<>
- void LoadImageRow<ByteRGB>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- unsigned char *destB = dest;
-
- 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, GLsizei width)
- {
- unsigned char *destB = dest;
-
- 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] = 0xFF;
- }
- }
-
- template<>
- void LoadImageRow<ShortRGB>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned short *sourceS = reinterpret_cast<const unsigned short*>(source);
- unsigned short *destS = reinterpret_cast<unsigned short*>(dest);
-
- 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, GLsizei width)
- {
- const unsigned short *sourceS = reinterpret_cast<const unsigned short*>(source);
- unsigned short *destS = reinterpret_cast<unsigned short*>(dest);
-
- 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, GLsizei width)
- {
- const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source);
- unsigned int *destI = reinterpret_cast<unsigned int*>(dest);
-
- 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, GLsizei width)
- {
- const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source);
- unsigned int *destI = reinterpret_cast<unsigned int*>(dest);
-
- 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<FloatRGB>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const float *sourceF = reinterpret_cast<const float*>(source);
- float *destF = reinterpret_cast<float*>(dest);
-
- for(int x = 0; x < width; x++)
- {
- destF[4 * x + 0] = sourceF[x * 3 + 0];
- destF[4 * x + 1] = sourceF[x * 3 + 1];
- destF[4 * x + 2] = sourceF[x * 3 + 2];
- destF[4 * x + 3] = 1.0f;
- }
- }
-
- template<>
- void LoadImageRow<HalfFloatRGB>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned short *sourceH = reinterpret_cast<const unsigned short*>(source);
- unsigned short *destH = reinterpret_cast<unsigned short*>(dest);
-
- for(int x = 0; x < width; x++)
- {
- destH[4 * x + 0] = sourceH[x * 3 + 0];
- destH[4 * x + 1] = sourceH[x * 3 + 1];
- destH[4 * x + 2] = sourceH[x * 3 + 2];
- destH[4 * x + 3] = 0x3C00; // SEEEEEMMMMMMMMMM, S = 0, E = 15, M = 0: 16bit flpt representation of 1
- }
- }
-
- template<>
- void LoadImageRow<RGBA4444>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned short *source4444 = reinterpret_cast<const unsigned short*>(source);
- unsigned char *dest4444 = dest;
-
- for(int x = 0; x < width; x++)
- {
- unsigned short rgba = source4444[x];
- dest4444[4 * x + 0] = ((rgba & 0x00F0) << 0) | ((rgba & 0x00F0) >> 4);
- dest4444[4 * x + 1] = ((rgba & 0x0F00) >> 4) | ((rgba & 0x0F00) >> 8);
- dest4444[4 * x + 2] = ((rgba & 0xF000) >> 8) | ((rgba & 0xF000) >> 12);
- dest4444[4 * x + 3] = ((rgba & 0x000F) << 4) | ((rgba & 0x000F) >> 0);
- }
- }
-
- template<>
- void LoadImageRow<RGBA5551>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned short *source5551 = reinterpret_cast<const unsigned short*>(source);
- unsigned char *dest5551 = dest;
-
- for(int x = 0; x < width; x++)
- {
- unsigned short rgba = source5551[x];
- dest5551[4 * x + 0] = ((rgba & 0x003E) << 2) | ((rgba & 0x003E) >> 3);
- dest5551[4 * x + 1] = ((rgba & 0x07C0) >> 3) | ((rgba & 0x07C0) >> 8);
- dest5551[4 * x + 2] = ((rgba & 0xF800) >> 8) | ((rgba & 0xF800) >> 13);
- dest5551[4 * x + 3] = (rgba & 0x0001) ? 0xFF : 0;
- }
- }
-
- template<>
- void LoadImageRow<R11G11B10F>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const sw::R11G11B10F *sourceRGB = reinterpret_cast<const sw::R11G11B10F*>(source);
- sw::half *destF = reinterpret_cast<sw::half*>(dest);
-
- for(int x = 0; x < width; x++, sourceRGB++, destF+=4)
- {
- sourceRGB->toRGB16F(destF);
- destF[3] = 1.0f;
- }
- }
-
- template<>
- void LoadImageRow<RGB9E5>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const sw::RGB9E5 *sourceRGB = reinterpret_cast<const sw::RGB9E5*>(source);
- sw::half *destF = reinterpret_cast<sw::half*>(dest);
-
- for(int x = 0; x < width; x++, sourceRGB++, destF += 4)
- {
- sourceRGB->toRGB16F(destF);
- destF[3] = 1.0f;
- }
- }
-
- template<>
- void LoadImageRow<D16>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned short *sourceD16 = reinterpret_cast<const unsigned short*>(source);
- float *destF = reinterpret_cast<float*>(dest);
-
- for(int x = 0; x < width; x++)
- {
- destF[x] = (float)sourceD16[x] / 0xFFFF;
- }
- }
-
- template<>
- void LoadImageRow<D24>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned int *sourceD24 = reinterpret_cast<const unsigned int*>(source);
- float *destF = reinterpret_cast<float*>(dest);
-
- for(int x = 0; x < width; x++)
- {
- destF[x] = (float)(sourceD24[x] & 0xFFFFFF00) / 0xFFFFFF00;
- }
- }
-
- template<>
- void LoadImageRow<D32>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned int *sourceD32 = reinterpret_cast<const unsigned int*>(source);
- float *destF = reinterpret_cast<float*>(dest);
-
- for(int x = 0; x < width; x++)
- {
- destF[x] = (float)sourceD32[x] / 0xFFFFFFFF;
- }
- }
-
- template<>
- void LoadImageRow<S8>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source);
- unsigned char *destI = dest;
-
- for(int x = 0; x < width; x++)
- {
- destI[x] = static_cast<unsigned char>(sourceI[x] & 0x000000FF); // FIXME: Quad layout
- }
- }
-
- template<>
- void LoadImageRow<D32F>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- const float *sourceF = reinterpret_cast<const float*>(source);
- float *destF = reinterpret_cast<float*>(dest);
-
- for(int x = 0; x < width; x++)
- {
- destF[x] = sw::clamp(sourceF[x], 0.0f, 1.0f);
- }
- }
-
- template<>
- void LoadImageRow<D32FS8>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- struct D32FS8 { float depth32f; unsigned int stencil24_8; };
- const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source);
- float *destF = reinterpret_cast<float*>(dest);
-
- for(int x = 0; x < width; x++)
- {
- destF[x] = sw::clamp(sourceD32FS8[x].depth32f, 0.0f, 1.0f);
- }
- }
-
- template<>
- void LoadImageRow<S24_8>(const unsigned char *source, unsigned char *dest, GLsizei width)
- {
- struct D32FS8 { float depth32f; unsigned int stencil24_8; };
- const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source);
- unsigned char *destI = dest;
-
- 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(GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, int destPitch, GLsizei destSlice, const void *input, void *buffer)
- {
- for(int z = 0; z < depth; z++)
- {
- const unsigned char *inputStart = static_cast<const unsigned char*>(input) + (z * inputPitch * inputHeight);
- unsigned char *destStart = static_cast<unsigned char*>(buffer) + (z * destSlice);
- for(int y = 0; y < height; y++)
- {
- const unsigned char *source = inputStart + y * inputPitch;
- unsigned char *dest = destStart + y * destPitch;
-
- LoadImageRow<dataType>(source, dest, width);
- }
- }
- }
-}
-
-namespace egl
-{
- sw::Format ConvertFormatType(GLenum format, GLenum type)
+ sw::Format ConvertReadFormatType(GLenum format, GLenum type)
{
switch(format)
{
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)
{
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)
{
case GL_HALF_FLOAT: return sw::FORMAT_A16B16G16R16F;
case GL_HALF_FLOAT_OES: return sw::FORMAT_A16B16G16R16F;
case GL_FLOAT: return sw::FORMAT_A32B32G32R32F;
+ case GL_UNSIGNED_INT_2_10_10_10_REV_EXT: return sw::FORMAT_A2B10G10R10;
default: UNREACHABLE(type);
}
break;
case GL_BGRA_EXT:
- case GL_BGRA8_EXT:
switch(type)
{
case GL_UNSIGNED_BYTE: return sw::FORMAT_A8R8G8B8;
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;
case GL_RED_INTEGER:
switch(type)
{
default: UNREACHABLE(type);
}
break;
+ case GL_RGB_INTEGER:
+ switch(type)
+ {
+ case GL_INT: return sw::FORMAT_X32B32G32R32I;
+ case GL_UNSIGNED_INT: return sw::FORMAT_X32B32G32R32UI;
+ default: UNREACHABLE(type);
+ }
+ break;
case GL_RGBA_INTEGER:
switch(type)
{
break;
default:
UNREACHABLE(format);
+ break;
}
return sw::FORMAT_NULL;
}
- sw::Format SelectInternalFormat(GLenum format, GLenum type)
+ bool IsUnsizedInternalFormat(GLint internalformat)
{
- switch(format)
+ switch(internalformat)
{
- case GL_ETC1_RGB8_OES:
- return sw::FORMAT_ETC1;
- case GL_COMPRESSED_R11_EAC:
- return sw::FORMAT_R11_EAC;
- case GL_COMPRESSED_SIGNED_R11_EAC:
- return sw::FORMAT_SIGNED_R11_EAC;
- case GL_COMPRESSED_RG11_EAC:
- return sw::FORMAT_RG11_EAC;
- case GL_COMPRESSED_SIGNED_RG11_EAC:
- return sw::FORMAT_SIGNED_RG11_EAC;
- case GL_COMPRESSED_RGB8_ETC2:
- return sw::FORMAT_RGB8_ETC2;
- case GL_COMPRESSED_SRGB8_ETC2:
- return sw::FORMAT_SRGB8_ETC2;
- case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
- return sw::FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
- case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
- return sw::FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2;
- case GL_COMPRESSED_RGBA8_ETC2_EAC:
- return sw::FORMAT_RGBA8_ETC2_EAC;
- case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
- return sw::FORMAT_SRGB8_ALPHA8_ETC2_EAC;
- case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
- return sw::FORMAT_RGBA_ASTC_4x4_KHR;
- case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
- return sw::FORMAT_RGBA_ASTC_5x4_KHR;
- case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
- return sw::FORMAT_RGBA_ASTC_5x5_KHR;
- case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
- return sw::FORMAT_RGBA_ASTC_6x5_KHR;
- case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
- return sw::FORMAT_RGBA_ASTC_6x6_KHR;
- case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
- return sw::FORMAT_RGBA_ASTC_8x5_KHR;
- case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
- return sw::FORMAT_RGBA_ASTC_8x6_KHR;
- case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
- return sw::FORMAT_RGBA_ASTC_8x8_KHR;
- case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
- return sw::FORMAT_RGBA_ASTC_10x5_KHR;
- case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
- return sw::FORMAT_RGBA_ASTC_10x6_KHR;
- case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
- return sw::FORMAT_RGBA_ASTC_10x8_KHR;
- case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
- return sw::FORMAT_RGBA_ASTC_10x10_KHR;
- case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
- return sw::FORMAT_RGBA_ASTC_12x10_KHR;
- case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
- return sw::FORMAT_RGBA_ASTC_12x12_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR;
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
- return sw::FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR;
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
- return sw::FORMAT_DXT1;
- case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
- return sw::FORMAT_DXT3;
- case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
- return sw::FORMAT_DXT5;
+ case GL_ALPHA:
+ case GL_LUMINANCE:
+ case GL_LUMINANCE_ALPHA:
+ case GL_RED:
+ case GL_RG:
+ case GL_RGB:
+ case GL_RGBA:
+ case GL_RED_INTEGER:
+ case GL_RG_INTEGER:
+ case GL_RGB_INTEGER:
+ case GL_RGBA_INTEGER:
+ case GL_BGRA_EXT:
+ case GL_DEPTH_COMPONENT:
+ case GL_DEPTH_STENCIL:
+ // GL_EXT_sRGB
+ // case GL_SRGB_EXT:
+ // case GL_SRGB_ALPHA_EXT:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ GLenum GetBaseInternalFormat(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ // [OpenGL ES 3.0 Table 3.13]
+ case GL_R8: return GL_RED;
+ case GL_R8_SNORM: return GL_RED;
+ case GL_RG8: return GL_RG;
+ case GL_RG8_SNORM: return GL_RG;
+ case GL_RGB8: return GL_RGB;
+ case GL_RGB8_SNORM: return GL_RGB;
+ case GL_RGB565: return GL_RGB;
+ case GL_RGBA4: return GL_RGBA;
+ case GL_RGB5_A1: return GL_RGBA;
+ case GL_RGBA8: return GL_RGBA;
+ case GL_RGBA8_SNORM: return GL_RGBA;
+ case GL_RGB10_A2: return GL_RGBA;
+ case GL_RGB10_A2UI: return GL_RGBA;
+ case GL_SRGB8: return GL_RGB;
+ case GL_SRGB8_ALPHA8: return GL_RGBA;
+ case GL_R16F: return GL_RED;
+ case GL_RG16F: return GL_RG;
+ case GL_RGB16F: return GL_RGB;
+ case GL_RGBA16F: return GL_RGBA;
+ case GL_R32F: return GL_RED;
+ case GL_RG32F: return GL_RG;
+ case GL_RGB32F: return GL_RGB;
+ case GL_RGBA32F: return GL_RGBA;
+ case GL_R11F_G11F_B10F: return GL_RGB;
+ case GL_RGB9_E5: return GL_RGB;
+ case GL_R8I: return GL_RED;
+ case GL_R8UI: return GL_RED;
+ case GL_R16I: return GL_RED;
+ case GL_R16UI: return GL_RED;
+ case GL_R32I: return GL_RED;
+ case GL_R32UI: return GL_RED;
+ case GL_RG8I: return GL_RG;
+ case GL_RG8UI: return GL_RG;
+ case GL_RG16I: return GL_RG;
+ case GL_RG16UI: return GL_RG;
+ case GL_RG32I: return GL_RG;
+ case GL_RG32UI: return GL_RG;
+ case GL_RGB8I: return GL_RGB;
+ case GL_RGB8UI: return GL_RGB;
+ case GL_RGB16I: return GL_RGB;
+ case GL_RGB16UI: return GL_RGB;
+ case GL_RGB32I: return GL_RGB;
+ case GL_RGB32UI: return GL_RGB;
+ case GL_RGBA8I: return GL_RGBA;
+ case GL_RGBA8UI: return GL_RGBA;
+ case GL_RGBA16I: return GL_RGBA;
+ case GL_RGBA16UI: return GL_RGBA;
+ case GL_RGBA32I: return GL_RGBA;
+ case GL_RGBA32UI: return GL_RGBA;
+
+ // GL_EXT_texture_storage
+ case GL_ALPHA8_EXT: return GL_ALPHA;
+ case GL_LUMINANCE8_ALPHA8_EXT: return GL_LUMINANCE_ALPHA;
+ case GL_LUMINANCE8_EXT: return GL_LUMINANCE;
+
+ case GL_BGRA8_EXT: return GL_BGRA_EXT; // GL_APPLE_texture_format_BGRA8888
+
+ case GL_DEPTH_COMPONENT24: return GL_DEPTH_COMPONENT;
+ case GL_DEPTH_COMPONENT32_OES: return GL_DEPTH_COMPONENT;
+ case GL_DEPTH_COMPONENT32F: return GL_DEPTH_COMPONENT;
+ case GL_DEPTH_COMPONENT16: return GL_DEPTH_COMPONENT;
+ case GL_DEPTH32F_STENCIL8: return GL_DEPTH_STENCIL;
+ case GL_DEPTH24_STENCIL8: return GL_DEPTH_STENCIL;
+ case GL_STENCIL_INDEX8: return GL_STENCIL_INDEX_OES;
default:
+ UNREACHABLE(internalformat);
break;
}
- switch(type)
+ return GL_NONE;
+ }
+
+ GLint GetSizedInternalFormat(GLint internalformat, GLenum type)
+ {
+ if(!IsUnsizedInternalFormat(internalformat))
{
- case GL_FLOAT:
- switch(format)
+ return internalformat;
+ }
+
+ switch(internalformat)
+ {
+ case GL_RGBA:
+ switch(type)
{
- case GL_ALPHA:
- case GL_ALPHA32F_EXT:
- return sw::FORMAT_A32F;
- case GL_LUMINANCE:
- case GL_LUMINANCE32F_EXT:
- return sw::FORMAT_L32F;
- case GL_LUMINANCE_ALPHA:
- case GL_LUMINANCE_ALPHA32F_EXT:
- return sw::FORMAT_A32L32F;
- 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:
- return sw::FORMAT_X32B32G32R32F;
- case GL_R11F_G11F_B10F:
- case GL_RGB9_E5:
- return sw::FORMAT_X16B16G16R16F_UNSIGNED;
- case GL_RGBA:
- case GL_RGBA32F:
- return sw::FORMAT_A32B32G32R32F;
- case GL_R16F:
- return sw::FORMAT_R16F;
- case GL_RG16F:
- return sw::FORMAT_G16R16F;
- case GL_RGB16F:
- return sw::FORMAT_X16B16G16R16F;
- case GL_RGBA16F:
- return sw::FORMAT_A16B16G16R16F;
- case GL_DEPTH_COMPONENT:
- case GL_DEPTH_COMPONENT32F:
- return sw::FORMAT_D32F;
- default:
- UNREACHABLE(format);
+ case GL_UNSIGNED_BYTE: return GL_RGBA8;
+ case GL_BYTE: return GL_RGBA8_SNORM;
+ case GL_UNSIGNED_SHORT_4_4_4_4: return GL_RGBA4;
+ case GL_UNSIGNED_SHORT_5_5_5_1: return GL_RGB5_A1;
+ case GL_UNSIGNED_INT_2_10_10_10_REV: return GL_RGB10_A2;
+ case GL_FLOAT: return GL_RGBA32F;
+ case GL_HALF_FLOAT: return GL_RGBA16F;
+ case GL_HALF_FLOAT_OES: return GL_RGBA16F;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_HALF_FLOAT:
- case GL_HALF_FLOAT_OES:
- switch(format)
+ case GL_RGBA_INTEGER:
+ switch(type)
{
- case GL_ALPHA:
- case GL_ALPHA16F_EXT:
- return sw::FORMAT_A16F;
- case GL_LUMINANCE:
- case GL_LUMINANCE16F_EXT:
- return sw::FORMAT_L16F;
- case GL_LUMINANCE_ALPHA:
- case GL_LUMINANCE_ALPHA16F_EXT:
- return sw::FORMAT_A16L16F;
- case GL_RED:
- case GL_R16F:
- return sw::FORMAT_R16F;
- case GL_RG:
- case GL_RG16F:
- return sw::FORMAT_G16R16F;
- case GL_RGBA:
- case GL_RGBA16F:
- return sw::FORMAT_A16B16G16R16F;
- case GL_RGB:
- case GL_RGB16F:
- return sw::FORMAT_X16B16G16R16F;
- case GL_R11F_G11F_B10F:
- case GL_RGB9_E5:
- return sw::FORMAT_X16B16G16R16F_UNSIGNED;
- default:
- UNREACHABLE(format);
+ case GL_UNSIGNED_BYTE: return GL_RGBA8UI;
+ case GL_BYTE: return GL_RGBA8I;
+ case GL_UNSIGNED_SHORT: return GL_RGBA16UI;
+ case GL_SHORT: return GL_RGBA16I;
+ case GL_UNSIGNED_INT: return GL_RGBA32UI;
+ case GL_INT: return GL_RGBA32I;
+ case GL_UNSIGNED_INT_2_10_10_10_REV: return GL_RGB10_A2UI;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_BYTE:
- switch(format)
+ case GL_RGB:
+ switch(type)
{
- case GL_R8_SNORM:
- case GL_R8:
- case GL_RED:
- return sw::FORMAT_R8_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_G8R8_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_X8B8G8R8_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_A8B8G8R8_SNORM;
- case GL_RGBA8I:
- case GL_RGBA_INTEGER:
- return sw::FORMAT_A8B8G8R8I;
- default:
- UNREACHABLE(format);
+ case GL_UNSIGNED_BYTE: return GL_RGB8;
+ case GL_BYTE: return GL_RGB8_SNORM;
+ case GL_UNSIGNED_SHORT_5_6_5: return GL_RGB565;
+ case GL_UNSIGNED_INT_10F_11F_11F_REV: return GL_R11F_G11F_B10F;
+ case GL_UNSIGNED_INT_5_9_9_9_REV: return GL_RGB9_E5;
+ case GL_FLOAT: return GL_RGB32F;
+ case GL_HALF_FLOAT: return GL_RGB16F;
+ case GL_HALF_FLOAT_OES: return GL_RGB16F;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_UNSIGNED_BYTE:
- switch(format)
+ case GL_RGB_INTEGER:
+ switch(type)
{
- 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:
- return sw::FORMAT_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:
- return sw::FORMAT_X8B8G8R8;
- case GL_SRGB8:
- return sw::FORMAT_SRGB8_X8;
- case GL_RGB8UI:
- case GL_RGB_INTEGER:
- return sw::FORMAT_X8B8G8R8UI;
- case GL_RGBA8_SNORM:
- case GL_RGBA8:
- case GL_RGBA:
- return sw::FORMAT_A8B8G8R8;
- case GL_SRGB8_ALPHA8:
- return sw::FORMAT_SRGB8_A8;
- case GL_RGBA8UI:
- case GL_RGBA_INTEGER:
- return sw::FORMAT_A8B8G8R8UI;
- case GL_BGRA_EXT:
- case GL_BGRA8_EXT:
- return sw::FORMAT_A8R8G8B8;
- case GL_ALPHA:
- case GL_ALPHA8_EXT:
- return sw::FORMAT_A8;
- 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(format);
+ case GL_UNSIGNED_BYTE: return GL_RGB8UI;
+ case GL_BYTE: return GL_RGB8I;
+ case GL_UNSIGNED_SHORT: return GL_RGB16UI;
+ case GL_SHORT: return GL_RGB16I;
+ case GL_UNSIGNED_INT: return GL_RGB32UI;
+ case GL_INT: return GL_RGB32I;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_SHORT:
- switch(format)
+ case GL_RG:
+ switch(type)
{
- 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);
+ case GL_UNSIGNED_BYTE: return GL_RG8;
+ case GL_BYTE: return GL_RG8_SNORM;
+ case GL_FLOAT: return GL_RG32F;
+ case GL_HALF_FLOAT: return GL_RG16F;
+ case GL_HALF_FLOAT_OES: return GL_RG16F;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_UNSIGNED_SHORT:
- switch(format)
+ case GL_RG_INTEGER:
+ switch(type)
{
- 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_D32F_LOCKABLE;
- default:
- UNREACHABLE(format);
+ case GL_UNSIGNED_BYTE: return GL_RG8UI;
+ case GL_BYTE: return GL_RG8I;
+ case GL_UNSIGNED_SHORT: return GL_RG16UI;
+ case GL_SHORT: return GL_RG16I;
+ case GL_UNSIGNED_INT: return GL_RG32UI;
+ case GL_INT: return GL_RG32I;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_INT:
- switch(format)
+ case GL_RED:
+ switch(type)
{
- 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);
+ case GL_UNSIGNED_BYTE: return GL_R8;
+ case GL_BYTE: return GL_R8_SNORM;
+ case GL_FLOAT: return GL_R32F;
+ case GL_HALF_FLOAT: return GL_R16F;
+ case GL_HALF_FLOAT_OES: return GL_R16F;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_UNSIGNED_INT:
- switch(format)
+ case GL_RED_INTEGER:
+ switch(type)
{
- 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_D32F_LOCKABLE;
- default:
- UNREACHABLE(format);
+ case GL_UNSIGNED_BYTE: return GL_R8UI;
+ case GL_BYTE: return GL_R8I;
+ case GL_UNSIGNED_SHORT: return GL_R16UI;
+ case GL_SHORT: return GL_R16I;
+ case GL_UNSIGNED_INT: return GL_R32UI;
+ case GL_INT: return GL_R32I;
+ default: UNREACHABLE(type); return GL_NONE;
+ }
+ case GL_LUMINANCE_ALPHA:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE: return GL_LUMINANCE8_ALPHA8_EXT;
+ case GL_FLOAT: return GL_LUMINANCE_ALPHA32F_EXT;
+ case GL_HALF_FLOAT: return GL_LUMINANCE_ALPHA16F_EXT;
+ case GL_HALF_FLOAT_OES: return GL_LUMINANCE_ALPHA16F_EXT;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_UNSIGNED_INT_24_8_OES:
- if(format == GL_DEPTH_STENCIL || format == GL_DEPTH24_STENCIL8)
+ case GL_LUMINANCE:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE: return GL_LUMINANCE8_EXT;
+ case GL_FLOAT: return GL_LUMINANCE32F_EXT;
+ case GL_HALF_FLOAT: return GL_LUMINANCE16F_EXT;
+ case GL_HALF_FLOAT_OES: return GL_LUMINANCE16F_EXT;
+ default: UNREACHABLE(type); return GL_NONE;
+ }
+ case GL_ALPHA:
+ switch(type)
{
- return sw::FORMAT_D32FS8_TEXTURE;
+ case GL_UNSIGNED_BYTE: return GL_ALPHA8_EXT;
+ case GL_FLOAT: return GL_ALPHA32F_EXT;
+ case GL_HALF_FLOAT: return GL_ALPHA16F_EXT;
+ case GL_HALF_FLOAT_OES: return GL_ALPHA16F_EXT;
+ default: UNREACHABLE(type); return GL_NONE;
}
- else UNREACHABLE(format);
- case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
- if(format == GL_DEPTH_STENCIL || format == GL_DEPTH32F_STENCIL8)
+ case GL_BGRA_EXT:
+ switch(type)
{
- return sw::FORMAT_D32FS8_TEXTURE;
+ case GL_UNSIGNED_BYTE: return GL_BGRA8_EXT;
+ case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT: // Only valid for glReadPixels calls.
+ case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT: // Only valid for glReadPixels calls.
+ default: UNREACHABLE(type); return GL_NONE;
}
- else UNREACHABLE(format);
- case GL_UNSIGNED_SHORT_4_4_4_4:
- return sw::FORMAT_A8R8G8B8;
- case GL_UNSIGNED_SHORT_5_5_5_1:
- return sw::FORMAT_A8R8G8B8;
- 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)
+ case GL_DEPTH_COMPONENT:
+ switch(type)
{
- return sw::FORMAT_A2B10G10R10UI;
+ case GL_UNSIGNED_SHORT: return GL_DEPTH_COMPONENT16;
+ case GL_UNSIGNED_INT: return GL_DEPTH_COMPONENT32_OES;
+ case GL_FLOAT: return GL_DEPTH_COMPONENT32F;
+ default: UNREACHABLE(type); return GL_NONE;
}
- else
+ case GL_DEPTH_STENCIL:
+ switch(type)
{
- return sw::FORMAT_A2B10G10R10;
+ case GL_UNSIGNED_INT_24_8: return GL_DEPTH24_STENCIL8;
+ case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return GL_DEPTH32F_STENCIL8;
+ default: UNREACHABLE(type); return GL_NONE;
}
- case GL_UNSIGNED_INT_10F_11F_11F_REV:
- case GL_UNSIGNED_INT_5_9_9_9_REV: // 5 is the exponent field, not alpha.
- return sw::FORMAT_X16B16G16R16F_UNSIGNED;
+
+ // GL_OES_texture_stencil8
+ // case GL_STENCIL_INDEX_OES / GL_UNSIGNED_BYTE: return GL_STENCIL_INDEX8;
+
+ // GL_EXT_sRGB
+ // case GL_SRGB_EXT / GL_UNSIGNED_BYTE: return GL_SRGB8;
+ // case GL_SRGB_ALPHA_EXT / GL_UNSIGNED_BYTE: return GL_SRGB8_ALPHA8;
+
+ default:
+ UNREACHABLE(internalformat);
+ }
+
+ return GL_NONE;
+ }
+
+ sw::Format SelectInternalFormat(GLint format)
+ {
+ switch(format)
+ {
+ case GL_RGBA4: return sw::FORMAT_A8B8G8R8;
+ case GL_RGB5_A1: return sw::FORMAT_A8B8G8R8;
+ case GL_RGBA8: return sw::FORMAT_A8B8G8R8;
+ case GL_RGB565: return sw::FORMAT_R5G6B5;
+ case GL_RGB8: return sw::FORMAT_X8B8G8R8;
+
+ case GL_DEPTH_COMPONENT32F: return sw::FORMAT_D32F_LOCKABLE;
+ case GL_DEPTH_COMPONENT16: return sw::FORMAT_D32F_LOCKABLE;
+ case GL_DEPTH_COMPONENT24: return sw::FORMAT_D32F_LOCKABLE;
+ case GL_DEPTH_COMPONENT32_OES: return sw::FORMAT_D32F_LOCKABLE;
+ case GL_DEPTH24_STENCIL8: return sw::FORMAT_D32FS8_TEXTURE;
+ case GL_DEPTH32F_STENCIL8: return sw::FORMAT_D32FS8_TEXTURE;
+ case GL_STENCIL_INDEX8: return sw::FORMAT_S8;
+
+ case GL_R8: return sw::FORMAT_R8;
+ case GL_RG8: return sw::FORMAT_G8R8;
+ case GL_R8I: return sw::FORMAT_R8I;
+ case GL_RG8I: return sw::FORMAT_G8R8I;
+ case GL_RGB8I: return sw::FORMAT_X8B8G8R8I;
+ case GL_RGBA8I: return sw::FORMAT_A8B8G8R8I;
+ case GL_R8UI: return sw::FORMAT_R8UI;
+ case GL_RG8UI: return sw::FORMAT_G8R8UI;
+ case GL_RGB8UI: return sw::FORMAT_X8B8G8R8UI;
+ case GL_RGBA8UI: return sw::FORMAT_A8B8G8R8UI;
+ case GL_R16I: return sw::FORMAT_R16I;
+ case GL_RG16I: return sw::FORMAT_G16R16I;
+ case GL_RGB16I: return sw::FORMAT_X16B16G16R16I;
+ case GL_RGBA16I: return sw::FORMAT_A16B16G16R16I;
+ case GL_R16UI: return sw::FORMAT_R16UI;
+ case GL_RG16UI: return sw::FORMAT_G16R16UI;
+ case GL_RGB16UI: return sw::FORMAT_X16B16G16R16UI;
+ case GL_RGBA16UI: return sw::FORMAT_A16B16G16R16UI;
+ case GL_R32I: return sw::FORMAT_R32I;
+ case GL_RG32I: return sw::FORMAT_G32R32I;
+ case GL_RGB32I: return sw::FORMAT_X32B32G32R32I;
+ case GL_RGBA32I: return sw::FORMAT_A32B32G32R32I;
+ case GL_R32UI: return sw::FORMAT_R32UI;
+ case GL_RG32UI: return sw::FORMAT_G32R32UI;
+ case GL_RGB32UI: return sw::FORMAT_X32B32G32R32UI;
+ case GL_RGBA32UI: return sw::FORMAT_A32B32G32R32UI;
+ case GL_R16F: return sw::FORMAT_R16F;
+ case GL_RG16F: return sw::FORMAT_G16R16F;
+ case GL_R11F_G11F_B10F: return sw::FORMAT_X16B16G16R16F_UNSIGNED;
+ case GL_RGB16F: return sw::FORMAT_X16B16G16R16F;
+ case GL_RGBA16F: return sw::FORMAT_A16B16G16R16F;
+ case GL_R32F: return sw::FORMAT_R32F;
+ case GL_RG32F: return sw::FORMAT_G32R32F;
+ case GL_RGB32F: return sw::FORMAT_X32B32G32R32F;
+ case GL_RGBA32F: return sw::FORMAT_A32B32G32R32F;
+ case GL_RGB10_A2: return sw::FORMAT_A2B10G10R10;
+ case GL_RGB10_A2UI: return sw::FORMAT_A2B10G10R10UI;
+ case GL_SRGB8: return sw::FORMAT_SRGB8_X8;
+ case GL_SRGB8_ALPHA8: return sw::FORMAT_SRGB8_A8;
+
+ case GL_ETC1_RGB8_OES: return sw::FORMAT_ETC1;
+ case GL_COMPRESSED_R11_EAC: return sw::FORMAT_R11_EAC;
+ case GL_COMPRESSED_SIGNED_R11_EAC: return sw::FORMAT_SIGNED_R11_EAC;
+ case GL_COMPRESSED_RG11_EAC: return sw::FORMAT_RG11_EAC;
+ case GL_COMPRESSED_SIGNED_RG11_EAC: return sw::FORMAT_SIGNED_RG11_EAC;
+ case GL_COMPRESSED_RGB8_ETC2: return sw::FORMAT_RGB8_ETC2;
+ case GL_COMPRESSED_SRGB8_ETC2: return sw::FORMAT_SRGB8_ETC2;
+ case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: return sw::FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
+ case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: return sw::FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2;
+ case GL_COMPRESSED_RGBA8_ETC2_EAC: return sw::FORMAT_RGBA8_ETC2_EAC;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: return sw::FORMAT_SRGB8_ALPHA8_ETC2_EAC;
+ case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: return sw::FORMAT_RGBA_ASTC_4x4_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: return sw::FORMAT_RGBA_ASTC_5x4_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: return sw::FORMAT_RGBA_ASTC_5x5_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: return sw::FORMAT_RGBA_ASTC_6x5_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: return sw::FORMAT_RGBA_ASTC_6x6_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: return sw::FORMAT_RGBA_ASTC_8x5_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: return sw::FORMAT_RGBA_ASTC_8x6_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: return sw::FORMAT_RGBA_ASTC_8x8_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: return sw::FORMAT_RGBA_ASTC_10x5_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: return sw::FORMAT_RGBA_ASTC_10x6_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: return sw::FORMAT_RGBA_ASTC_10x8_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: return sw::FORMAT_RGBA_ASTC_10x10_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: return sw::FORMAT_RGBA_ASTC_12x10_KHR;
+ case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: return sw::FORMAT_RGBA_ASTC_12x12_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR;
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: return sw::FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR;
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: return sw::FORMAT_DXT1;
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: return sw::FORMAT_DXT1;
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: return sw::FORMAT_DXT3;
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: return sw::FORMAT_DXT5;
+
+ case GL_ALPHA32F_EXT: return sw::FORMAT_A32F;
+ case GL_LUMINANCE32F_EXT: return sw::FORMAT_L32F;
+ case GL_LUMINANCE_ALPHA32F_EXT: return sw::FORMAT_A32L32F;
+ case GL_RGB9_E5: return sw::FORMAT_X16B16G16R16F_UNSIGNED;
+ case GL_ALPHA16F_EXT: return sw::FORMAT_A16F;
+ case GL_LUMINANCE16F_EXT: return sw::FORMAT_L16F;
+ case GL_LUMINANCE_ALPHA16F_EXT: return sw::FORMAT_A16L16F;
+ case GL_R8_SNORM: return sw::FORMAT_R8_SNORM;
+ case GL_RG8_SNORM: return sw::FORMAT_G8R8_SNORM;
+ case GL_RGB8_SNORM: return sw::FORMAT_X8B8G8R8_SNORM;
+ case GL_RGBA8_SNORM: return sw::FORMAT_A8B8G8R8_SNORM;
+ case GL_LUMINANCE8_EXT: return sw::FORMAT_L8;
+ case GL_LUMINANCE8_ALPHA8_EXT: return sw::FORMAT_A8L8;
+ case GL_BGRA8_EXT: return sw::FORMAT_A8R8G8B8;
+ case GL_ALPHA8_EXT: return sw::FORMAT_A8;
+
+ 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);
+ UNREACHABLE(format); // Not a sized internal format.
+ return sw::FORMAT_NULL;
}
-
- return sw::FORMAT_NULL;
}
// Returns the size, in bytes, of a single client-side pixel.
UNREACHABLE(format);
}
- return 0;
+ return 0;
+ }
+
+ GLsizei ComputePitch(GLsizei width, GLenum format, GLenum type, GLint alignment)
+ {
+ ASSERT(alignment > 0 && sw::isPow2(alignment));
+
+ GLsizei rawPitch = ComputePixelSize(format, type) * width;
+ return (rawPitch + alignment - 1) & ~(alignment - 1);
+ }
+
+ size_t ComputePackingOffset(GLenum format, GLenum type, GLsizei width, GLsizei height, const gl::PixelStorageModes &storageModes)
+ {
+ GLsizei pitchB = ComputePitch(width, format, type, storageModes.alignment);
+ return (storageModes.skipImages * height + storageModes.skipRows) * pitchB + storageModes.skipPixels * ComputePixelSize(format, type);
+ }
+
+ inline GLsizei ComputeCompressedPitch(GLsizei width, GLenum format)
+ {
+ return ComputeCompressedSize(width, 1, format);
+ }
+
+ inline int GetNumCompressedBlocks(int w, int h, int blockSizeX, int blockSizeY)
+ {
+ return ((w + blockSizeX - 1) / blockSizeX) * ((h + blockSizeY - 1) / blockSizeY);
+ }
+
+ GLsizei ComputeCompressedSize(GLsizei width, GLsizei height, GLenum format)
+ {
+ switch(format)
+ {
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ case GL_ETC1_RGB8_OES:
+ case GL_COMPRESSED_R11_EAC:
+ case GL_COMPRESSED_SIGNED_R11_EAC:
+ case GL_COMPRESSED_RGB8_ETC2:
+ case GL_COMPRESSED_SRGB8_ETC2:
+ case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+ case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+ return 8 * GetNumCompressedBlocks(width, height, 4, 4);
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+ case GL_COMPRESSED_RG11_EAC:
+ case GL_COMPRESSED_SIGNED_RG11_EAC:
+ case GL_COMPRESSED_RGBA8_ETC2_EAC:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
+ case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 4, 4);
+ case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 5, 4);
+ case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 5, 5);
+ case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 6, 5);
+ case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 6, 6);
+ case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 8, 5);
+ case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 8, 6);
+ case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 8, 8);
+ case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 10, 5);
+ case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 10, 6);
+ case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 10, 8);
+ case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 10, 10);
+ case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 12, 10);
+ case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
+ case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
+ return 16 * GetNumCompressedBlocks(width, height, 12, 12);
+ default:
+ UNREACHABLE(format);
+ return 0;
+ }
+ }
+}
+
+namespace egl
+{
+ enum TransferType
+ {
+ Bytes,
+ RGB8toRGBX8,
+ RGB16toRGBX16,
+ RGB32toRGBX32,
+ RGB32FtoRGBX32F,
+ RGB16FtoRGBX16F,
+ RGBA4toRGBA8,
+ RGBA5_A1toRGBA8,
+ R11G11B10FtoRGBX16F,
+ RGB9_E5FtoRGBX16F,
+ D16toD32F,
+ D24X8toD32F,
+ D32toD32F,
+ D32FtoD32F_CLAMPED,
+ D32FX32toD32F,
+ X24S8toS8,
+ X56S8toS8,
+ RGBA1010102toRGBA8,
+ RGB8toRGB565,
+ R32FtoR16F,
+ RG32FtoRG16F,
+ RGB32FtoRGB16F,
+ RGB32FtoRGB16F_UNSIGNED,
+ RGBA32FtoRGBA16F
+ };
+
+ template<TransferType transferType>
+ void TransferRow(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes);
+
+ template<>
+ void TransferRow<Bytes>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ memcpy(dest, source, width * bytes);
+ }
+
+ template<>
+ void TransferRow<RGB8toRGBX8>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ unsigned char *destB = dest;
+
+ 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] = 0xFF;
+ }
+ }
+
+ template<>
+ void TransferRow<RGB16toRGBX16>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const unsigned short *sourceS = reinterpret_cast<const unsigned short*>(source);
+ unsigned short *destS = reinterpret_cast<unsigned short*>(dest);
+
+ 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 TransferRow<RGB32toRGBX32>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source);
+ unsigned int *destI = reinterpret_cast<unsigned int*>(dest);
+
+ 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 TransferRow<RGB32FtoRGBX32F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const float *sourceF = reinterpret_cast<const float*>(source);
+ float *destF = reinterpret_cast<float*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ destF[4 * x + 0] = sourceF[x * 3 + 0];
+ destF[4 * x + 1] = sourceF[x * 3 + 1];
+ destF[4 * x + 2] = sourceF[x * 3 + 2];
+ destF[4 * x + 3] = 1.0f;
+ }
+ }
+
+ template<>
+ void TransferRow<RGB16FtoRGBX16F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const unsigned short *sourceH = reinterpret_cast<const unsigned short*>(source);
+ unsigned short *destH = reinterpret_cast<unsigned short*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ destH[4 * x + 0] = sourceH[x * 3 + 0];
+ destH[4 * x + 1] = sourceH[x * 3 + 1];
+ destH[4 * x + 2] = sourceH[x * 3 + 2];
+ destH[4 * x + 3] = 0x3C00; // SEEEEEMMMMMMMMMM, S = 0, E = 15, M = 0: 16-bit floating-point representation of 1.0
+ }
+ }
+
+ template<>
+ void TransferRow<RGBA4toRGBA8>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const unsigned short *source4444 = reinterpret_cast<const unsigned short*>(source);
+ unsigned char *dest4444 = dest;
+
+ for(int x = 0; x < width; x++)
+ {
+ unsigned short rgba = source4444[x];
+ dest4444[4 * x + 0] = ((rgba & 0xF000) >> 8) | ((rgba & 0xF000) >> 12);
+ dest4444[4 * x + 1] = ((rgba & 0x0F00) >> 4) | ((rgba & 0x0F00) >> 8);
+ dest4444[4 * x + 2] = ((rgba & 0x00F0) << 0) | ((rgba & 0x00F0) >> 4);
+ dest4444[4 * x + 3] = ((rgba & 0x000F) << 4) | ((rgba & 0x000F) >> 0);
+ }
+ }
+
+ template<>
+ void TransferRow<RGBA5_A1toRGBA8>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const unsigned short *source5551 = reinterpret_cast<const unsigned short*>(source);
+ unsigned char *dest8888 = dest;
+
+ for(int x = 0; x < width; x++)
+ {
+ unsigned short rgba = source5551[x];
+ dest8888[4 * x + 0] = ((rgba & 0xF800) >> 8) | ((rgba & 0xF800) >> 13);
+ dest8888[4 * x + 1] = ((rgba & 0x07C0) >> 3) | ((rgba & 0x07C0) >> 8);
+ dest8888[4 * x + 2] = ((rgba & 0x003E) << 2) | ((rgba & 0x003E) >> 3);
+ dest8888[4 * x + 3] = (rgba & 0x0001) ? 0xFF : 0;
+ }
+ }
+
+ template<>
+ void TransferRow<RGBA1010102toRGBA8>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const unsigned int *source1010102 = reinterpret_cast<const unsigned int*>(source);
+ unsigned char *dest8888 = dest;
+
+ for(int x = 0; x < width; x++)
+ {
+ unsigned int rgba = source1010102[x];
+ dest8888[4 * x + 0] = sw::unorm<8>((rgba & 0x000003FF) * (1.0f / 0x000003FF));
+ dest8888[4 * x + 1] = sw::unorm<8>((rgba & 0x000FFC00) * (1.0f / 0x000FFC00));
+ dest8888[4 * x + 2] = sw::unorm<8>((rgba & 0x3FF00000) * (1.0f / 0x3FF00000));
+ dest8888[4 * x + 3] = sw::unorm<8>((rgba & 0xC0000000) * (1.0f / 0xC0000000));
+ }
+ }
+
+ template<>
+ void TransferRow<RGB8toRGB565>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ unsigned short *dest565 = reinterpret_cast<unsigned short*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ float r = source[3 * x + 0] * (1.0f / 0xFF);
+ float g = source[3 * x + 1] * (1.0f / 0xFF);
+ float b = source[3 * x + 2] * (1.0f / 0xFF);
+ dest565[x] = (sw::unorm<5>(r) << 11) | (sw::unorm<6>(g) << 5) | (sw::unorm<5>(b) << 0);
+ }
+ }
+
+ template<>
+ void TransferRow<R11G11B10FtoRGBX16F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const sw::R11G11B10F *sourceRGB = reinterpret_cast<const sw::R11G11B10F*>(source);
+ sw::half *destF = reinterpret_cast<sw::half*>(dest);
+
+ for(int x = 0; x < width; x++, sourceRGB++, destF += 4)
+ {
+ sourceRGB->toRGB16F(destF);
+ destF[3] = 1.0f;
+ }
+ }
+
+ template<>
+ void TransferRow<RGB9_E5FtoRGBX16F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const sw::RGB9E5 *sourceRGB = reinterpret_cast<const sw::RGB9E5*>(source);
+ sw::half *destF = reinterpret_cast<sw::half*>(dest);
+
+ for(int x = 0; x < width; x++, sourceRGB++, destF += 4)
+ {
+ sourceRGB->toRGB16F(destF);
+ destF[3] = 1.0f;
+ }
+ }
+
+ template<>
+ void TransferRow<R32FtoR16F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const float *source32F = reinterpret_cast<const float*>(source);
+ sw::half *dest16F = reinterpret_cast<sw::half*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ dest16F[x] = source32F[x];
+ }
+ }
+
+ template<>
+ void TransferRow<RG32FtoRG16F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const float *source32F = reinterpret_cast<const float*>(source);
+ sw::half *dest16F = reinterpret_cast<sw::half*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ dest16F[2 * x + 0] = source32F[2 * x + 0];
+ dest16F[2 * x + 1] = source32F[2 * x + 1];
+ }
+ }
+
+ template<>
+ void TransferRow<RGB32FtoRGB16F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const float *source32F = reinterpret_cast<const float*>(source);
+ sw::half *dest16F = reinterpret_cast<sw::half*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ dest16F[4 * x + 0] = source32F[3 * x + 0];
+ dest16F[4 * x + 1] = source32F[3 * x + 1];
+ dest16F[4 * x + 2] = source32F[3 * x + 2];
+ dest16F[4 * x + 3] = 1.0f;
+ }
+ }
+
+ template<>
+ void TransferRow<RGB32FtoRGB16F_UNSIGNED>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const float *source32F = reinterpret_cast<const float*>(source);
+ sw::half *dest16F = reinterpret_cast<sw::half*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ dest16F[4 * x + 0] = std::max(source32F[3 * x + 0], 0.0f);
+ dest16F[4 * x + 1] = std::max(source32F[3 * x + 1], 0.0f);
+ dest16F[4 * x + 2] = std::max(source32F[3 * x + 2], 0.0f);
+ dest16F[4 * x + 3] = 1.0f;
+ }
+ }
+
+ template<>
+ void TransferRow<RGBA32FtoRGBA16F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const float *source32F = reinterpret_cast<const float*>(source);
+ sw::half *dest16F = reinterpret_cast<sw::half*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ dest16F[4 * x + 0] = source32F[4 * x + 0];
+ dest16F[4 * x + 1] = source32F[4 * x + 1];
+ dest16F[4 * x + 2] = source32F[4 * x + 2];
+ dest16F[4 * x + 3] = source32F[4 * x + 3];
+ }
}
- GLsizei ComputePitch(GLsizei width, GLenum format, GLenum type, GLint alignment)
+ template<>
+ void TransferRow<D16toD32F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
{
- ASSERT(alignment > 0 && sw::isPow2(alignment));
+ const unsigned short *sourceD16 = reinterpret_cast<const unsigned short*>(source);
+ float *destF = reinterpret_cast<float*>(dest);
- GLsizei rawPitch = ComputePixelSize(format, type) * width;
- return (rawPitch + alignment - 1) & ~(alignment - 1);
+ for(int x = 0; x < width; x++)
+ {
+ destF[x] = (float)sourceD16[x] / 0xFFFF;
+ }
}
- size_t ComputePackingOffset(GLenum format, GLenum type, GLsizei width, GLsizei height, const PixelStorageModes &storageModes)
+ template<>
+ void TransferRow<D24X8toD32F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
{
- GLsizei pitchB = ComputePitch(width, format, type, storageModes.alignment);
- return (storageModes.skipImages * height + storageModes.skipRows) * pitchB + storageModes.skipPixels * ComputePixelSize(format, type);
+ const unsigned int *sourceD24 = reinterpret_cast<const unsigned int*>(source);
+ float *destF = reinterpret_cast<float*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ destF[x] = (float)(sourceD24[x] & 0xFFFFFF00) / 0xFFFFFF00;
+ }
}
- inline GLsizei ComputeCompressedPitch(GLsizei width, GLenum format)
+ template<>
+ void TransferRow<D32toD32F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
{
- return ComputeCompressedSize(width, 1, format);
+ const unsigned int *sourceD32 = reinterpret_cast<const unsigned int*>(source);
+ float *destF = reinterpret_cast<float*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ destF[x] = (float)sourceD32[x] / 0xFFFFFFFF;
+ }
}
- GLsizei ComputeCompressedSize(GLsizei width, GLsizei height, GLenum format)
+ template<>
+ void TransferRow<D32FtoD32F_CLAMPED>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
{
- switch(format)
+ const float *sourceF = reinterpret_cast<const float*>(source);
+ float *destF = reinterpret_cast<float*>(dest);
+
+ for(int x = 0; x < width; x++)
{
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
- case GL_ETC1_RGB8_OES:
- case GL_COMPRESSED_R11_EAC:
- case GL_COMPRESSED_SIGNED_R11_EAC:
- case GL_COMPRESSED_RGB8_ETC2:
- case GL_COMPRESSED_SRGB8_ETC2:
- case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
- case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
- return 8 * getNumBlocks(width, height, 4, 4);
- case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
- case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
- case GL_COMPRESSED_RG11_EAC:
- case GL_COMPRESSED_SIGNED_RG11_EAC:
- case GL_COMPRESSED_RGBA8_ETC2_EAC:
- case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
- case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
- return 16 * getNumBlocks(width, height, 4, 4);
- case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
- return 16 * getNumBlocks(width, height, 5, 4);
- case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
- return 16 * getNumBlocks(width, height, 5, 5);
- case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
- return 16 * getNumBlocks(width, height, 6, 5);
- case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
- return 16 * getNumBlocks(width, height, 6, 6);
- case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
- return 16 * getNumBlocks(width, height, 8, 5);
- case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
- return 16 * getNumBlocks(width, height, 8, 6);
- case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
- return 16 * getNumBlocks(width, height, 8, 8);
- case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
- return 16 * getNumBlocks(width, height, 10, 5);
- case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
- return 16 * getNumBlocks(width, height, 10, 6);
- case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
- return 16 * getNumBlocks(width, height, 10, 8);
- case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
- return 16 * getNumBlocks(width, height, 10, 10);
- case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
- return 16 * getNumBlocks(width, height, 12, 10);
- case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
- case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
- return 16 * getNumBlocks(width, height, 12, 12);
- default:
- return 0;
+ destF[x] = sw::clamp(sourceF[x], 0.0f, 1.0f);
+ }
+ }
+
+ template<>
+ void TransferRow<D32FX32toD32F>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ struct D32FS8 { float depth32f; unsigned int stencil24_8; };
+ const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source);
+ float *destF = reinterpret_cast<float*>(dest);
+
+ for(int x = 0; x < width; x++)
+ {
+ destF[x] = sw::clamp(sourceD32FS8[x].depth32f, 0.0f, 1.0f);
+ }
+ }
+
+ template<>
+ void TransferRow<X24S8toS8>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ const unsigned int *sourceI = reinterpret_cast<const unsigned int*>(source);
+ unsigned char *destI = dest;
+
+ for(int x = 0; x < width; x++)
+ {
+ destI[x] = static_cast<unsigned char>(sourceI[x] & 0x000000FF); // FIXME: Quad layout
+ }
+ }
+
+ template<>
+ void TransferRow<X56S8toS8>(unsigned char *dest, const unsigned char *source, GLsizei width, GLsizei bytes)
+ {
+ struct D32FS8 { float depth32f; unsigned int stencil24_8; };
+ const D32FS8 *sourceD32FS8 = reinterpret_cast<const D32FS8*>(source);
+ unsigned char *destI = dest;
+
+ for(int x = 0; x < width; x++)
+ {
+ destI[x] = static_cast<unsigned char>(sourceD32FS8[x].stencil24_8 & 0x000000FF); // FIXME: Quad layout
+ }
+ }
+
+ struct Rectangle
+ {
+ GLsizei bytes;
+ GLsizei width;
+ GLsizei height;
+ GLsizei depth;
+ int inputPitch;
+ int inputHeight;
+ int destPitch;
+ GLsizei destSlice;
+ };
+
+ template<TransferType transferType>
+ void Transfer(void *buffer, const void *input, const Rectangle &rect)
+ {
+ for(int z = 0; z < rect.depth; z++)
+ {
+ const unsigned char *inputStart = static_cast<const unsigned char*>(input) + (z * rect.inputPitch * rect.inputHeight);
+ unsigned char *destStart = static_cast<unsigned char*>(buffer) + (z * rect.destSlice);
+ for(int y = 0; y < rect.height; y++)
+ {
+ const unsigned char *source = inputStart + y * rect.inputPitch;
+ unsigned char *dest = destStart + y * rect.destPitch;
+
+ TransferRow<transferType>(dest, source, rect.width, rect.bytes);
+ }
}
}
class ImageImplementation : public Image
{
public:
- ImageImplementation(Texture *parentTexture, GLsizei width, GLsizei height, GLenum format, GLenum type)
- : Image(parentTexture, width, height, format, type) {}
- ImageImplementation(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type)
- : Image(parentTexture, width, height, depth, border, format, type) {}
- ImageImplementation(GLsizei width, GLsizei height, GLenum format, GLenum type, int pitchP)
- : Image(width, height, format, type, pitchP) {}
- ImageImplementation(GLsizei width, GLsizei height, sw::Format internalFormat, int multiSampleDepth, bool lockable)
- : Image(width, height, internalFormat, multiSampleDepth, lockable) {}
+ ImageImplementation(Texture *parentTexture, GLsizei width, GLsizei height, GLint internalformat)
+ : Image(parentTexture, width, height, internalformat) {}
+ ImageImplementation(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLint internalformat)
+ : Image(parentTexture, width, height, depth, border, internalformat) {}
+ ImageImplementation(GLsizei width, GLsizei height, GLint internalformat, int pitchP)
+ : Image(width, height, internalformat, pitchP) {}
+ ImageImplementation(GLsizei width, GLsizei height, GLint internalformat, int multiSampleDepth, bool lockable)
+ : Image(width, height, internalformat, multiSampleDepth, lockable) {}
~ImageImplementation() override
{
}
};
- Image *Image::create(Texture *parentTexture, GLsizei width, GLsizei height, GLenum format, GLenum type)
+ Image *Image::create(Texture *parentTexture, GLsizei width, GLsizei height, GLint internalformat)
{
- return new ImageImplementation(parentTexture, width, height, format, type);
+ return new ImageImplementation(parentTexture, width, height, internalformat);
}
- Image *Image::create(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type)
+ Image *Image::create(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLint internalformat)
{
- return new ImageImplementation(parentTexture, width, height, depth, border, format, type);
+ return new ImageImplementation(parentTexture, width, height, depth, border, internalformat);
}
- Image *Image::create(GLsizei width, GLsizei height, GLenum format, GLenum type, int pitchP)
+ Image *Image::create(GLsizei width, GLsizei height, GLint internalformat, int pitchP)
{
- return new ImageImplementation(width, height, format, type, pitchP);
+ return new ImageImplementation(width, height, internalformat, pitchP);
}
- Image *Image::create(GLsizei width, GLsizei height, sw::Format internalFormat, int multiSampleDepth, bool lockable)
+ Image *Image::create(GLsizei width, GLsizei height, GLint internalformat, int multiSampleDepth, bool lockable)
{
- return new ImageImplementation(width, height, internalFormat, multiSampleDepth, lockable);
+ return new ImageImplementation(width, height, internalformat, multiSampleDepth, lockable);
}
Image::~Image()
return parentTexture == parent;
}
- void Image::loadImageData(Context *context, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const PixelStorageModes &unpackParameters, const void *pixels)
+ void Image::loadImageData(GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, GLenum format, GLenum type, const void *input, void *buffer)
{
- sw::Format uploadFormat = SelectInternalFormat(format, type);
- if(uploadFormat == sw::FORMAT_NULL)
- {
- return;
- }
-
- GLsizei inputWidth = (unpackParameters.rowLength == 0) ? width : unpackParameters.rowLength;
- GLsizei inputPitch = ComputePitch(inputWidth, format, type, unpackParameters.alignment);
- GLsizei inputHeight = (unpackParameters.imageHeight == 0) ? height : unpackParameters.imageHeight;
- char *input = ((char*)pixels) + ComputePackingOffset(format, type, inputWidth, inputHeight, unpackParameters);
-
- if(uploadFormat == internalFormat ||
- (uploadFormat == sw::FORMAT_A8B8G8R8 && internalFormat == sw::FORMAT_SRGB8_A8) ||
- (uploadFormat == sw::FORMAT_X8B8G8R8 && internalFormat == sw::FORMAT_SRGB8_X8) ||
- (uploadFormat == sw::FORMAT_A2B10G10R10 && internalFormat == sw::FORMAT_A2B10G10R10UI))
+ Rectangle rect;
+ rect.bytes = gl::ComputePixelSize(format, type);
+ rect.width = width;
+ rect.height = height;
+ rect.depth = depth;
+ rect.inputPitch = inputPitch;
+ rect.inputHeight = inputHeight;
+ rect.destPitch = getPitch();
+ rect.destSlice = getSlice();
+
+ // [OpenGL ES 3.0.5] table 3.2 and 3.3.
+ switch(format)
{
- void *buffer = lock(xoffset, yoffset, zoffset, sw::LOCK_WRITEONLY);
-
- if(buffer)
+ case GL_RGBA:
+ switch(type)
{
- // OpenGL ES 3.0.5 table 3.2.
- switch(format)
+ case GL_UNSIGNED_BYTE:
+ switch(internalformat)
+ {
+ case GL_RGBA8:
+ case GL_SRGB8_ALPHA8:
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_RGB5_A1:
+ case GL_RGBA4:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_A8B8G8R8);
+ return Transfer<Bytes>(buffer, input, rect);
+ default:
+ UNREACHABLE(internalformat);
+ }
+ case GL_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA8_SNORM && getExternalFormat() == sw::FORMAT_A8B8G8R8_SNORM);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT_4_4_4_4:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA4 && getExternalFormat() == sw::FORMAT_A8B8G8R8);
+ return Transfer<RGBA4toRGBA8>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT_5_5_5_1:
+ ASSERT_OR_RETURN(internalformat == GL_RGB5_A1 && getExternalFormat() == sw::FORMAT_A8B8G8R8);
+ return Transfer<RGBA5_A1toRGBA8>(buffer, input, rect);
+ case GL_UNSIGNED_INT_2_10_10_10_REV:
+ switch(internalformat)
{
- case GL_RED:
- case GL_RED_INTEGER:
- case GL_ALPHA:
- case GL_LUMINANCE:
- switch(type)
- {
- case GL_BYTE:
- case GL_UNSIGNED_BYTE:
- LoadImageData<Bytes_1>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_FLOAT:
- ASSERT(format != GL_RED_INTEGER);
- LoadImageData<Bytes_4>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_HALF_FLOAT:
- case GL_HALF_FLOAT_OES:
- ASSERT(format != GL_RED_INTEGER);
- LoadImageData<Bytes_2>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_SHORT:
- case GL_UNSIGNED_SHORT:
- LoadImageData<Bytes_2>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_INT:
- case GL_UNSIGNED_INT:
- LoadImageData<Bytes_4>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- default:
- UNREACHABLE(type);
- }
- break;
- case GL_RG:
- case GL_RG_INTEGER:
- case GL_LUMINANCE_ALPHA:
- switch(type)
- {
- case GL_BYTE:
- case GL_UNSIGNED_BYTE:
- LoadImageData<Bytes_2>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_FLOAT:
- ASSERT(format != GL_RG_INTEGER);
- LoadImageData<Bytes_8>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_HALF_FLOAT:
- case GL_HALF_FLOAT_OES:
- ASSERT(format != GL_RG_INTEGER);
- LoadImageData<Bytes_4>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_SHORT:
- case GL_UNSIGNED_SHORT:
- LoadImageData<Bytes_4>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_INT:
- case GL_UNSIGNED_INT:
- LoadImageData<Bytes_8>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- default:
- UNREACHABLE(type);
- }
- break;
- case GL_RGB:
- case GL_RGB_INTEGER:
- switch(type)
- {
- case GL_BYTE:
- LoadImageData<ByteRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_BYTE:
- LoadImageData<UByteRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_SHORT_5_6_5:
- ASSERT(format == GL_RGB);
- LoadImageData<Bytes_2>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_INT_10F_11F_11F_REV:
- ASSERT(format == GL_RGB);
- LoadImageData<R11G11B10F>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_INT_5_9_9_9_REV:
- ASSERT(format == GL_RGB);
- LoadImageData<RGB9E5>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_FLOAT:
- ASSERT(format == GL_RGB);
- LoadImageData<FloatRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_HALF_FLOAT:
- case GL_HALF_FLOAT_OES:
- ASSERT(format == GL_RGB);
- LoadImageData<HalfFloatRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_SHORT:
- LoadImageData<ShortRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_SHORT:
- LoadImageData<UShortRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_INT:
- LoadImageData<IntRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_INT:
- LoadImageData<UIntRGB>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- default:
- UNREACHABLE(type);
- }
- break;
- case GL_RGBA:
- case GL_RGBA_INTEGER:
- case GL_BGRA_EXT:
- switch(type)
- {
- case GL_BYTE:
- case GL_UNSIGNED_BYTE:
- LoadImageData<Bytes_4>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_SHORT_4_4_4_4:
- ASSERT(format == GL_RGBA);
- LoadImageData<RGBA4444>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- // case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
- // ASSERT(format == GL_BGRA_EXT);
- // LoadImageData<ABGR4444>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- // break;
- case GL_UNSIGNED_SHORT_5_5_5_1:
- ASSERT(format == GL_RGBA);
- LoadImageData<RGBA5551>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- // case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
- // ASSERT(format == GL_BGRA_EXT);
- // LoadImageData<ABGR5551>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- // break;
- case GL_UNSIGNED_INT_2_10_10_10_REV:
- ASSERT(format != GL_BGRA_EXT);
- LoadImageData<Bytes_4>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_FLOAT:
- ASSERT(format == GL_RGBA);
- LoadImageData<Bytes_16>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_HALF_FLOAT:
- case GL_HALF_FLOAT_OES:
- ASSERT(format == GL_RGBA);
- LoadImageData<Bytes_8>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_SHORT:
- case GL_UNSIGNED_SHORT:
- ASSERT(format != GL_BGRA_EXT);
- LoadImageData<Bytes_8>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_INT:
- case GL_UNSIGNED_INT:
- ASSERT(format != GL_BGRA_EXT);
- LoadImageData<Bytes_16>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- default:
- UNREACHABLE(type);
- }
- break;
- case GL_DEPTH_COMPONENT:
- switch(type)
- {
- case GL_FLOAT:
- LoadImageData<D32F>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_SHORT:
- LoadImageData<D16>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- case GL_UNSIGNED_INT:
- LoadImageData<D32>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
- break;
- default:
- UNREACHABLE(type);
- }
- break;
- case GL_DEPTH_STENCIL:
- switch(type)
- {
- case GL_UNSIGNED_INT_24_8:
- 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);
- }
- break;
+ case GL_RGB10_A2:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_A2B10G10R10);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_RGB5_A1:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_A8B8G8R8);
+ return Transfer<RGBA1010102toRGBA8>(buffer, input, rect);
default:
- UNREACHABLE(format);
+ UNREACHABLE(internalformat);
+ }
+ case GL_HALF_FLOAT:
+ case GL_HALF_FLOAT_OES:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA16F && getExternalFormat() == sw::FORMAT_A16B16G16R16F);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_FLOAT:
+ switch(internalformat)
+ {
+ case GL_RGBA32F: return Transfer<Bytes>(buffer, input, rect);
+ case GL_RGBA16F: return Transfer<RGBA32FtoRGBA16F>(buffer, input, rect);
+ default: UNREACHABLE(internalformat);
}
+ default:
+ UNREACHABLE(type);
}
-
- unlock();
- }
- else
- {
- sw::Surface *source = sw::Surface::create(width, height, depth, ConvertFormatType(format, type), input, inputPitch, inputPitch * inputHeight);
- sw::Rect sourceRect(0, 0, width, height);
- sw::Rect destRect(xoffset, yoffset, xoffset + width, yoffset + height);
- context->blit(source, sourceRect, this, destRect);
- delete source;
+ case GL_RGBA_INTEGER:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA8UI && getExternalFormat() == sw::FORMAT_A8B8G8R8UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA8I && getExternalFormat() == sw::FORMAT_A8B8G8R8I);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA16UI && getExternalFormat() == sw::FORMAT_A16B16G16R16UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA16I && getExternalFormat() == sw::FORMAT_A16B16G16R16I);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_INT:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA32UI && getExternalFormat() == sw::FORMAT_A32B32G32R32UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_INT:
+ ASSERT_OR_RETURN(internalformat == GL_RGBA32I && getExternalFormat() == sw::FORMAT_A32B32G32R32I);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_INT_2_10_10_10_REV:
+ ASSERT_OR_RETURN(internalformat == GL_RGB10_A2UI && getExternalFormat() == sw::FORMAT_A2B10G10R10UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_BGRA_EXT:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_BGRA8_EXT && getExternalFormat() == sw::FORMAT_A8R8G8B8);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT: // Only valid for glReadPixels calls.
+ case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT: // Only valid for glReadPixels calls.
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_RGB:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ switch(internalformat)
+ {
+ case GL_RGB8: return Transfer<RGB8toRGBX8>(buffer, input, rect);
+ case GL_SRGB8: return Transfer<RGB8toRGBX8>(buffer, input, rect);
+ case GL_RGB565: return Transfer<RGB8toRGB565>(buffer, input, rect);
+ default: UNREACHABLE(internalformat);
+ }
+ case GL_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RGB8_SNORM && getExternalFormat() == sw::FORMAT_X8B8G8R8_SNORM);
+ return Transfer<RGB8toRGBX8>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT_5_6_5:
+ ASSERT_OR_RETURN(internalformat == GL_RGB565 && getExternalFormat() == sw::FORMAT_R5G6B5);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_INT_10F_11F_11F_REV:
+ ASSERT_OR_RETURN(internalformat == GL_R11F_G11F_B10F && getExternalFormat() == sw::FORMAT_X16B16G16R16F_UNSIGNED);
+ return Transfer<R11G11B10FtoRGBX16F>(buffer, input, rect);
+ case GL_UNSIGNED_INT_5_9_9_9_REV:
+ ASSERT_OR_RETURN(internalformat == GL_RGB9_E5 && getExternalFormat() == sw::FORMAT_X16B16G16R16F_UNSIGNED);
+ return Transfer<RGB9_E5FtoRGBX16F>(buffer, input, rect);
+ case GL_HALF_FLOAT:
+ case GL_HALF_FLOAT_OES:
+ switch(internalformat)
+ {
+ case GL_RGB16F:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_X16B16G16R16F);
+ return Transfer<RGB16FtoRGBX16F>(buffer, input, rect);
+ case GL_R11F_G11F_B10F:
+ case GL_RGB9_E5:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_X16B16G16R16F_UNSIGNED);
+ return Transfer<RGB16FtoRGBX16F>(buffer, input, rect);
+ default:
+ UNREACHABLE(internalformat);
+ }
+ case GL_FLOAT:
+ switch(internalformat)
+ {
+ case GL_RGB32F:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_X32B32G32R32F);
+ return Transfer<RGB32FtoRGBX32F>(buffer, input, rect);
+ case GL_RGB16F:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_X16B16G16R16F);
+ return Transfer<RGB32FtoRGB16F>(buffer, input, rect);
+ case GL_R11F_G11F_B10F:
+ case GL_RGB9_E5:
+ ASSERT_OR_RETURN(getExternalFormat() == sw::FORMAT_X16B16G16R16F_UNSIGNED);
+ return Transfer<RGB32FtoRGB16F_UNSIGNED>(buffer, input, rect);
+ default:
+ UNREACHABLE(internalformat);
+ }
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_RGB_INTEGER:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RGB8UI && getExternalFormat() == sw::FORMAT_X8B8G8R8UI);
+ return Transfer<RGB8toRGBX8>(buffer, input, rect);
+ case GL_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RGB8I && getExternalFormat() == sw::FORMAT_X8B8G8R8I);
+ return Transfer<RGB8toRGBX8>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_RGB16UI && getExternalFormat() == sw::FORMAT_X16B16G16R16UI);
+ return Transfer<RGB16toRGBX16>(buffer, input, rect);
+ case GL_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_RGB16I && getExternalFormat() == sw::FORMAT_X16B16G16R16I);
+ return Transfer<RGB16toRGBX16>(buffer, input, rect);
+ case GL_UNSIGNED_INT:
+ ASSERT_OR_RETURN(internalformat == GL_RGB32UI && getExternalFormat() == sw::FORMAT_X32B32G32R32UI);
+ return Transfer<RGB32toRGBX32>(buffer, input, rect);
+ case GL_INT:
+ ASSERT_OR_RETURN(internalformat == GL_RGB32I && getExternalFormat() == sw::FORMAT_X32B32G32R32I);
+ return Transfer<RGB32toRGBX32>(buffer, input, rect);
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_RG:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ case GL_BYTE:
+ case GL_HALF_FLOAT:
+ case GL_HALF_FLOAT_OES:
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_FLOAT:
+ switch(internalformat)
+ {
+ case GL_RG32F: return Transfer<Bytes>(buffer, input, rect);
+ case GL_RG16F: return Transfer<RG32FtoRG16F>(buffer, input, rect);
+ default: UNREACHABLE(internalformat);
+ }
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_RG_INTEGER:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RG8UI && getExternalFormat() == sw::FORMAT_G8R8UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_RG8I && getExternalFormat() == sw::FORMAT_G8R8I);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_RG16UI && getExternalFormat() == sw::FORMAT_G16R16UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_RG16I && getExternalFormat() == sw::FORMAT_G16R16I);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_INT:
+ ASSERT_OR_RETURN(internalformat == GL_RG32UI && getExternalFormat() == sw::FORMAT_G32R32UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_INT:
+ ASSERT_OR_RETURN(internalformat == GL_RG32I && getExternalFormat() == sw::FORMAT_G32R32I);
+ return Transfer<Bytes>(buffer, input, rect);
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_RED:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ case GL_BYTE:
+ case GL_HALF_FLOAT:
+ case GL_HALF_FLOAT_OES:
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_FLOAT:
+ switch(internalformat)
+ {
+ case GL_R32F: return Transfer<Bytes>(buffer, input, rect);
+ case GL_R16F: return Transfer<R32FtoR16F>(buffer, input, rect);
+ default: UNREACHABLE(internalformat);
+ }
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_RED_INTEGER:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_R8UI && getExternalFormat() == sw::FORMAT_R8UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_BYTE:
+ ASSERT_OR_RETURN(internalformat == GL_R8I && getExternalFormat() == sw::FORMAT_R8I);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_R16UI && getExternalFormat() == sw::FORMAT_R16UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_SHORT:
+ ASSERT_OR_RETURN(internalformat == GL_R16I && getExternalFormat() == sw::FORMAT_R16I);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_UNSIGNED_INT:
+ ASSERT_OR_RETURN(internalformat == GL_R32UI && getExternalFormat() == sw::FORMAT_R32UI);
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_INT:
+ ASSERT_OR_RETURN(internalformat == GL_R32I && getExternalFormat() == sw::FORMAT_R32I);
+ return Transfer<Bytes>(buffer, input, rect);
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_DEPTH_COMPONENT:
+ switch(type)
+ {
+ case GL_UNSIGNED_SHORT: return Transfer<D16toD32F>(buffer, input, rect);
+ case GL_UNSIGNED_INT: return Transfer<D32toD32F>(buffer, input, rect);
+ case GL_FLOAT: return Transfer<D32FtoD32F_CLAMPED>(buffer, input, rect);
+ case GL_DEPTH_COMPONENT24: // Only valid for glRenderbufferStorage calls.
+ case GL_DEPTH_COMPONENT32_OES: // Only valid for glRenderbufferStorage calls.
+ default: UNREACHABLE(type);
+ }
+ case GL_DEPTH_STENCIL:
+ switch(type)
+ {
+ case GL_UNSIGNED_INT_24_8: return Transfer<D24X8toD32F>(buffer, input, rect);
+ case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return Transfer<D32FX32toD32F>(buffer, input, rect);
+ default: UNREACHABLE(type);
+ }
+ case GL_LUMINANCE_ALPHA:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_FLOAT:
+ switch(internalformat)
+ {
+ case GL_RG32F: return Transfer<Bytes>(buffer, input, rect);
+ case GL_RG16F: return Transfer<RG32FtoRG16F>(buffer, input, rect);
+ default: UNREACHABLE(internalformat);
+ }
+ case GL_HALF_FLOAT:
+ case GL_HALF_FLOAT_OES:
+ return Transfer<Bytes>(buffer, input, rect);
+ default:
+ UNREACHABLE(type);
+ }
+ case GL_LUMINANCE:
+ case GL_ALPHA:
+ switch(type)
+ {
+ case GL_UNSIGNED_BYTE:
+ return Transfer<Bytes>(buffer, input, rect);
+ case GL_FLOAT:
+ switch(internalformat)
+ {
+ case GL_R32F: return Transfer<Bytes>(buffer, input, rect);
+ case GL_R16F: return Transfer<R32FtoR16F>(buffer, input, rect);
+ default: UNREACHABLE(internalformat);
+ }
+ case GL_HALF_FLOAT:
+ case GL_HALF_FLOAT_OES:
+ return Transfer<Bytes>(buffer, input, rect);
+ default:
+ UNREACHABLE(type);
+ }
+ default:
+ UNREACHABLE(format);
}
}
- void Image::loadD24S8ImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, const void *input, void *buffer)
+ void Image::loadStencilData(GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, GLenum format, GLenum type, const void *input, void *buffer)
{
- LoadImageData<D24>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
+ Rectangle rect;
+ rect.bytes = gl::ComputePixelSize(format, type);
+ rect.width = width;
+ rect.height = height;
+ rect.depth = depth;
+ rect.inputPitch = inputPitch;
+ rect.inputHeight = inputHeight;
+ rect.destPitch = getStencilPitchB();
+ rect.destSlice = getStencilSliceB();
- unsigned char *stencil = reinterpret_cast<unsigned char*>(lockStencil(0, 0, 0, sw::PUBLIC));
-
- if(stencil)
+ switch(type)
{
- LoadImageData<S8>(width, height, depth, inputPitch, inputHeight, getStencilPitchB(), getHeight(), input, stencil);
-
- unlockStencil();
+ case GL_UNSIGNED_INT_24_8: return Transfer<X24S8toS8>(buffer, input, rect);
+ case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return Transfer<X56S8toS8>(buffer, input, rect);
+ default: UNREACHABLE(format);
}
}
- void Image::loadD32FS8ImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, const void *input, void *buffer)
+ void Image::loadImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels)
{
- LoadImageData<D32FS8>(width, height, depth, inputPitch, inputHeight, getPitch(), getSlice(), input, buffer);
+ GLsizei inputWidth = (unpackParameters.rowLength == 0) ? width : unpackParameters.rowLength;
+ GLsizei inputPitch = gl::ComputePitch(inputWidth, format, type, unpackParameters.alignment);
+ GLsizei inputHeight = (unpackParameters.imageHeight == 0) ? height : unpackParameters.imageHeight;
+ char *input = ((char*)pixels) + gl::ComputePackingOffset(format, type, inputWidth, inputHeight, unpackParameters);
+
+ void *buffer = lock(xoffset, yoffset, zoffset, sw::LOCK_WRITEONLY);
- unsigned char *stencil = reinterpret_cast<unsigned char*>(lockStencil(0, 0, 0, sw::PUBLIC));
+ if(buffer)
+ {
+ loadImageData(width, height, depth, inputPitch, inputHeight, format, type, input, buffer);
+ }
+
+ unlock();
- if(stencil)
+ if(hasStencil())
{
- LoadImageData<S24_8>(width, height, depth, inputPitch, inputHeight, getStencilPitchB(), getHeight(), input, stencil);
+ unsigned char *stencil = reinterpret_cast<unsigned char*>(lockStencil(xoffset, yoffset, zoffset, sw::PUBLIC));
+
+ if(stencil)
+ {
+ loadStencilData(width, height, depth, inputPitch, inputHeight, format, type, input, stencil);
+ }
unlockStencil();
}
void Image::loadCompressedData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
{
- int inputPitch = ComputeCompressedPitch(width, format);
+ int inputPitch = gl::ComputeCompressedPitch(width, internalformat);
int inputSlice = imageSize / depth;
int rows = inputSlice / inputPitch;
#define SW_YV12_BT709 0x48315659 // YCrCb 4:2:0 Planar, 16-byte aligned, BT.709 color space, studio swing
#define SW_YV12_JFIF 0x4A315659 // YCrCb 4:2:0 Planar, 16-byte aligned, BT.601 color space, full swing
-namespace egl
+namespace gl
{
-class Context;
-
struct PixelStorageModes
{
GLint rowLength = 0;
GLint skipImages = 0;
};
-sw::Format ConvertFormatType(GLenum format, GLenum type);
-sw::Format SelectInternalFormat(GLenum format, GLenum type);
+GLint GetSizedInternalFormat(GLint internalFormat, GLenum type);
+sw::Format ConvertReadFormatType(GLenum format, GLenum type);
+sw::Format SelectInternalFormat(GLint format);
+bool IsUnsizedInternalFormat(GLint internalformat);
+GLenum GetBaseInternalFormat(GLint internalformat);
GLsizei ComputePitch(GLsizei width, GLenum format, GLenum type, GLint alignment);
GLsizei ComputeCompressedSize(GLsizei width, GLsizei height, GLenum format);
size_t ComputePackingOffset(GLenum format, GLenum type, GLsizei width, GLsizei height, const PixelStorageModes &storageModes);
+}
+
+namespace egl
+{
+
class [[clang::lto_visibility_public]] Image : public sw::Surface, public gl::Object
{
protected:
// 2D texture image
- Image(Texture *parentTexture, GLsizei width, GLsizei height, GLenum format, GLenum type)
- : sw::Surface(parentTexture->getResource(), width, height, 1, 0, 1, SelectInternalFormat(format, type), true, true),
- width(width), height(height), depth(1), format(format), type(type), internalFormat(SelectInternalFormat(format, type)),
- parentTexture(parentTexture)
+ Image(Texture *parentTexture, GLsizei width, GLsizei height, GLint internalformat)
+ : sw::Surface(parentTexture->getResource(), width, height, 1, 0, 1, gl::SelectInternalFormat(internalformat), true, true),
+ width(width), height(height), depth(1), internalformat(internalformat), parentTexture(parentTexture)
{
shared = false;
Object::addRef();
}
// 3D/Cube texture image
- Image(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type)
- : sw::Surface(parentTexture->getResource(), width, height, depth, border, 1, SelectInternalFormat(format, type), true, true),
- width(width), height(height), depth(depth), format(format), type(type), internalFormat(SelectInternalFormat(format, type)),
- parentTexture(parentTexture)
+ Image(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLint internalformat)
+ : sw::Surface(parentTexture->getResource(), width, height, depth, border, 1, gl::SelectInternalFormat(internalformat), true, true),
+ width(width), height(height), depth(depth), internalformat(internalformat), parentTexture(parentTexture)
{
shared = false;
Object::addRef();
}
// Native EGL image
- Image(GLsizei width, GLsizei height, GLenum format, GLenum type, int pitchP)
- : sw::Surface(nullptr, width, height, 1, 0, 1, SelectInternalFormat(format, type), true, true, pitchP),
- width(width), height(height), depth(1), format(format), type(type), internalFormat(SelectInternalFormat(format, type)),
- parentTexture(nullptr)
+ Image(GLsizei width, GLsizei height, GLint internalformat, int pitchP)
+ : sw::Surface(nullptr, width, height, 1, 0, 1, gl::SelectInternalFormat(internalformat), true, true, pitchP),
+ width(width), height(height), depth(1), internalformat(internalformat), parentTexture(nullptr)
{
shared = true;
Object::addRef();
}
// Render target
- Image(GLsizei width, GLsizei height, sw::Format internalFormat, int multiSampleDepth, bool lockable)
- : sw::Surface(nullptr, width, height, 1, 0, multiSampleDepth, internalFormat, lockable, true),
- width(width), height(height), depth(1), format(0 /*GL_NONE*/), type(0 /*GL_NONE*/), internalFormat(internalFormat),
- parentTexture(nullptr)
+ Image(GLsizei width, GLsizei height, GLint internalformat, int multiSampleDepth, bool lockable)
+ : sw::Surface(nullptr, width, height, 1, 0, multiSampleDepth, gl::SelectInternalFormat(internalformat), lockable, true),
+ width(width), height(height), depth(1), internalformat(internalformat), parentTexture(nullptr)
{
shared = false;
Object::addRef();
public:
// 2D texture image
- static Image *create(Texture *parentTexture, GLsizei width, GLsizei height, GLenum format, GLenum type);
+ static Image *create(Texture *parentTexture, GLsizei width, GLsizei height, GLint internalformat);
// 3D/Cube texture image
- static Image *create(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLenum format, GLenum type);
+ static Image *create(Texture *parentTexture, GLsizei width, GLsizei height, GLsizei depth, int border, GLint internalformat);
// Native EGL image
- static Image *create(GLsizei width, GLsizei height, GLenum format, GLenum type, int pitchP);
+ static Image *create(GLsizei width, GLsizei height, GLint internalformat, int pitchP);
// Render target
- static Image *create(GLsizei width, GLsizei height, sw::Format internalFormat, int multiSampleDepth, bool lockable);
+ static Image *create(GLsizei width, GLsizei height, GLint internalformat, int multiSampleDepth, bool lockable);
GLsizei getWidth() const
{
return depth;
}
- GLenum getFormat() const
+ GLint getFormat() const
{
- return format;
- }
-
- GLenum getType() const
- {
- return type;
- }
-
- sw::Format getInternalFormat() const
- {
- return internalFormat;
+ return internalformat;
}
bool isShared() const
void *lockInternal(int x, int y, int z, sw::Lock lock, sw::Accessor client) override = 0;
void unlockInternal() override = 0;
- void loadImageData(Context *context, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const PixelStorageModes &unpackParameters, const void *pixels);
+ void loadImageData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels);
void loadCompressedData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
void release() override = 0;
const GLsizei width;
const GLsizei height;
const int depth;
- const GLenum format;
- const GLenum type;
- const sw::Format internalFormat;
+ const GLint internalformat;
bool shared; // Used as an EGLImage
~Image() override = 0;
- 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);
+ void loadImageData(GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, GLenum format, GLenum type, const void *input, void *buffer);
+ void loadStencilData(GLsizei width, GLsizei height, GLsizei depth, int inputPitch, int inputHeight, GLenum format, GLenum type, const void *input, void *buffer);
};
#ifdef __ANDROID__
}
}
-inline GLenum GLPixelTypeFromAndroid(int halFormat)
-{
- switch(halFormat)
- {
- case HAL_PIXEL_FORMAT_RGBA_8888: return GL_UNSIGNED_BYTE;
-#if ANDROID_PLATFORM_SDK_VERSION > 16
- case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: return GL_UNSIGNED_BYTE;
-#endif
- case HAL_PIXEL_FORMAT_RGBX_8888: return GL_UNSIGNED_BYTE;
- case HAL_PIXEL_FORMAT_BGRA_8888: return GL_UNSIGNED_BYTE;
- case HAL_PIXEL_FORMAT_RGB_565: return GL_UNSIGNED_SHORT_5_6_5;
- case HAL_PIXEL_FORMAT_YV12: return GL_UNSIGNED_BYTE;
-#ifdef GRALLOC_MODULE_API_VERSION_0_2
- case HAL_PIXEL_FORMAT_YCbCr_420_888: return GL_UNSIGNED_BYTE;
-#endif
- case HAL_PIXEL_FORMAT_RGB_888: // Unsupported.
- default:
- ALOGE("Unsupported EGL image format %d", halFormat); ASSERT(false);
- return GL_NONE;
- }
-}
-
class AndroidNativeImage : public egl::Image
{
public:
explicit AndroidNativeImage(ANativeWindowBuffer *nativeBuffer)
: egl::Image(nativeBuffer->width, nativeBuffer->height,
GLPixelFormatFromAndroid(nativeBuffer->format),
- GLPixelTypeFromAndroid(nativeBuffer->format),
nativeBuffer->stride),
nativeBuffer(nativeBuffer)
{
virtual egl::Image *getRenderTarget() = 0;
virtual egl::Image *getDepthStencil() = 0;
- virtual sw::Format getInternalFormat() const = 0;
-
virtual EGLint getWidth() const = 0;
virtual EGLint getHeight() const = 0;
return config->mSurfaceType;
}
-sw::Format Surface::getInternalFormat() const
-{
- return config->mRenderTargetFormat;
-}
-
EGLint Surface::getWidth() const
{
return width;
virtual EGLint getConfigID() const;
virtual EGLenum getSurfaceType() const;
- sw::Format getInternalFormat() const override;
EGLint getWidth() const override;
EGLint getHeight() const override;
void Texture::setCompressedImage(GLsizei imageSize, const void *pixels, Image *image)
{
- if(pixels && image && (imageSize > 0)) // imageSize's correlation to width and height is already validated with egl::ComputeCompressedSize() at the API level
+ if(pixels && image && (imageSize > 0)) // imageSize's correlation to width and height is already validated with gl::ComputeCompressedSize() at the API level
{
image->loadCompressedData(0, 0, 0, image->getWidth(), image->getHeight(), 1, imageSize, pixels);
}
return error(GL_INVALID_OPERATION);
}
- if(pixels && (imageSize > 0)) // imageSize's correlation to width and height is already validated with egl::ComputeCompressedSize() at the API level
+ if(pixels && (imageSize > 0)) // imageSize's correlation to width and height is already validated with gl::ComputeCompressedSize() at the API level
{
image->loadCompressedData(xoffset, yoffset, 0, width, height, 1, imageSize, pixels);
}
}
}
- GLsizei outputPitch = egl::ComputePitch(width, format, type, mState.packAlignment);
+ GLsizei outputPitch = gl::ComputePitch(width, format, type, mState.packAlignment);
// Sized query sanity check
if(bufSize)
stencilBuffer->clearStencil(stencil, mask, clearRect.x0, clearRect.y0, clearRect.width(), clearRect.height());
}
- egl::Image *Device::createDepthStencilSurface(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)
- {
- if(height > OUTLINE_RESOLUTION)
- {
- ERR("Invalid parameters: %dx%d", width, height);
- return nullptr;
- }
-
- bool lockable = true;
-
- switch(format)
- {
- // case FORMAT_D15S1:
- case FORMAT_D24S8:
- case FORMAT_D24X8:
- // case FORMAT_D24X4S4:
- case FORMAT_D24FS8:
- case FORMAT_D32:
- case FORMAT_D16:
- lockable = false;
- break;
- // case FORMAT_S8_LOCKABLE:
- // case FORMAT_D16_LOCKABLE:
- case FORMAT_D32F_LOCKABLE:
- // case FORMAT_D32_LOCKABLE:
- case FORMAT_DF24S8:
- case FORMAT_DF16S8:
- lockable = true;
- break;
- default:
- UNREACHABLE(format);
- }
-
- egl::Image *surface = egl::Image::create(width, height, format, multiSampleDepth, lockable);
-
- if(!surface)
- {
- ERR("Out of memory");
- return nullptr;
- }
-
- return surface;
- }
-
- egl::Image *Device::createRenderTarget(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool lockable)
- {
- if(height > OUTLINE_RESOLUTION)
- {
- ERR("Invalid parameters: %dx%d", width, height);
- return nullptr;
- }
-
- egl::Image *surface = egl::Image::create(width, height, format, multiSampleDepth, lockable);
-
- if(!surface)
- {
- ERR("Out of memory");
- return nullptr;
- }
-
- return surface;
- }
-
void Device::drawIndexedPrimitive(sw::DrawType type, unsigned int indexOffset, unsigned int primitiveCount)
{
if(!bindResources() || !primitiveCount)
void clearColor(float red, float green, float blue, float alpha, unsigned int rgbaMask);
void clearDepth(float z);
void clearStencil(unsigned int stencil, unsigned int mask);
- egl::Image *createDepthStencilSurface(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
- egl::Image *createRenderTarget(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool lockable);
void drawIndexedPrimitive(sw::DrawType type, unsigned int indexOffset, unsigned int primitiveCount);
void drawPrimitive(sw::DrawType type, unsigned int primiveCount);
void setScissorEnable(bool enable);
if(colorbuffer)
{
- switch(colorbuffer->getInternalFormat())
+ switch(colorbuffer->getFormat())
{
- case sw::FORMAT_A8R8G8B8: return GL_BGRA_EXT;
- case sw::FORMAT_A8B8G8R8: return GL_RGBA;
- case sw::FORMAT_X8R8G8B8: return GL_BGRA_EXT;
- case sw::FORMAT_X8B8G8R8: return GL_RGBA;
- case sw::FORMAT_A1R5G5B5: return GL_BGRA_EXT;
- case sw::FORMAT_R5G6B5: return GL_RGB;
+ case GL_BGRA8_EXT: return GL_BGRA_EXT;
+ case GL_RGBA4_OES: return GL_RGBA;
+ case GL_RGB5_A1_OES: return GL_RGBA;
+ case GL_RGBA8_OES: return GL_RGBA;
+ case GL_RGB565_OES: return GL_RGBA;
+ case GL_RGB8_OES: return GL_RGB;
default:
- UNREACHABLE(colorbuffer->getInternalFormat());
+ UNREACHABLE(colorbuffer->getFormat());
}
}
if(colorbuffer)
{
- switch(colorbuffer->getInternalFormat())
+ switch(colorbuffer->getFormat())
{
- case sw::FORMAT_A8R8G8B8: return GL_UNSIGNED_BYTE;
- case sw::FORMAT_A8B8G8R8: return GL_UNSIGNED_BYTE;
- case sw::FORMAT_X8R8G8B8: return GL_UNSIGNED_BYTE;
- case sw::FORMAT_X8B8G8R8: return GL_UNSIGNED_BYTE;
- case sw::FORMAT_A1R5G5B5: return GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT;
- case sw::FORMAT_R5G6B5: return GL_UNSIGNED_SHORT_5_6_5;
+ case GL_BGRA8_EXT: return GL_UNSIGNED_BYTE;
+ case GL_RGBA4_OES: return GL_UNSIGNED_SHORT_4_4_4_4;
+ case GL_RGB5_A1_OES: return GL_UNSIGNED_SHORT_5_5_5_1;
+ case GL_RGBA8_OES: return GL_UNSIGNED_BYTE;
+ case GL_RGB565_OES: return GL_UNSIGNED_SHORT_5_6_5;
+ case GL_RGB8_OES: return GL_UNSIGNED_BYTE;
default:
- UNREACHABLE(colorbuffer->getInternalFormat());
+ UNREACHABLE(colorbuffer->getFormat());
}
}
GLuint RenderbufferInterface::getRedSize() const
{
- return sw2es::GetRedSize(getInternalFormat());
+ return GetRedSize(getFormat());
}
GLuint RenderbufferInterface::getGreenSize() const
{
- return sw2es::GetGreenSize(getInternalFormat());
+ return GetGreenSize(getFormat());
}
GLuint RenderbufferInterface::getBlueSize() const
{
- return sw2es::GetBlueSize(getInternalFormat());
+ return GetBlueSize(getFormat());
}
GLuint RenderbufferInterface::getAlphaSize() const
{
- return sw2es::GetAlphaSize(getInternalFormat());
+ return GetAlphaSize(getFormat());
}
GLuint RenderbufferInterface::getDepthSize() const
{
- return sw2es::GetDepthSize(getInternalFormat());
+ return GetDepthSize(getFormat());
}
GLuint RenderbufferInterface::getStencilSize() const
{
- return sw2es::GetStencilSize(getInternalFormat());
+ return GetStencilSize(getFormat());
}
///// RenderbufferTexture2D Implementation ////////
return mTexture2D->getFormat(GL_TEXTURE_2D, 0);
}
-sw::Format RenderbufferTexture2D::getInternalFormat() const
-{
- return mTexture2D->getInternalFormat(GL_TEXTURE_2D, 0);
-}
-
GLsizei RenderbufferTexture2D::getSamples() const
{
return 0;
return mInstance->getFormat();
}
-sw::Format Renderbuffer::getInternalFormat() const
-{
- return mInstance->getInternalFormat();
-}
-
GLuint Renderbuffer::getRedSize() const
{
return mInstance->getRedSize();
{
mWidth = 0;
mHeight = 0;
- format = GL_RGBA4_OES;
- internalFormat = sw::FORMAT_A8B8G8R8;
+ format = GL_NONE;
mSamples = 0;
}
return format;
}
-sw::Format RenderbufferStorage::getInternalFormat() const
-{
- return internalFormat;
-}
-
GLsizei RenderbufferStorage::getSamples() const
{
return mSamples;
mWidth = renderTarget->getWidth();
mHeight = renderTarget->getHeight();
- internalFormat = renderTarget->getInternalFormat();
- format = sw2es::ConvertBackBufferFormat(internalFormat);
+ format = renderTarget->getFormat();
mSamples = renderTarget->getDepth() & ~1;
}
}
-Colorbuffer::Colorbuffer(int width, int height, GLenum format, GLsizei samples) : mRenderTarget(nullptr)
+Colorbuffer::Colorbuffer(int width, int height, GLenum internalformat, GLsizei samples) : mRenderTarget(nullptr)
{
- Device *device = getDevice();
-
- sw::Format requestedFormat = es2sw::ConvertRenderbufferFormat(format);
int supportedSamples = Context::getSupportedMultisampleCount(samples);
if(width > 0 && height > 0)
{
- mRenderTarget = device->createRenderTarget(width, height, requestedFormat, supportedSamples, false);
+ if(height > sw::OUTLINE_RESOLUTION)
+ {
+ error(GL_OUT_OF_MEMORY);
+ return;
+ }
+
+ mRenderTarget = egl::Image::create(width, height, internalformat, supportedSamples, false);
if(!mRenderTarget)
{
mWidth = width;
mHeight = height;
- this->format = format;
- internalFormat = requestedFormat;
+ format = internalformat;
mSamples = supportedSamples;
}
mWidth = depthStencil->getWidth();
mHeight = depthStencil->getHeight();
- internalFormat = depthStencil->getInternalFormat();
- format = sw2es::ConvertDepthStencilFormat(internalFormat);
+ format = depthStencil->getFormat();
mSamples = depthStencil->getDepth() & ~1;
}
}
-DepthStencilbuffer::DepthStencilbuffer(int width, int height, GLsizei samples) : mDepthStencil(nullptr)
+DepthStencilbuffer::DepthStencilbuffer(int width, int height, GLenum internalformat, GLsizei samples) : mDepthStencil(nullptr)
{
- Device *device = getDevice();
-
int supportedSamples = Context::getSupportedMultisampleCount(samples);
if(width > 0 && height > 0)
{
- mDepthStencil = device->createDepthStencilSurface(width, height, sw::FORMAT_D24S8, supportedSamples, false);
+ if(height > sw::OUTLINE_RESOLUTION)
+ {
+ error(GL_OUT_OF_MEMORY);
+ return;
+ }
+
+ mDepthStencil = egl::Image::create(width, height, internalformat, supportedSamples, false);
if(!mDepthStencil)
{
mWidth = width;
mHeight = height;
- format = GL_DEPTH24_STENCIL8_OES;
- internalFormat = sw::FORMAT_D24S8;
+ format = internalformat;
mSamples = supportedSamples;
}
Depthbuffer::Depthbuffer(egl::Image *depthStencil) : DepthStencilbuffer(depthStencil)
{
- if(depthStencil)
- {
- format = GL_DEPTH_COMPONENT16_OES; // If the renderbuffer parameters are queried, the calling function
- // will expect one of the valid renderbuffer formats for use in
- // glRenderbufferStorage
- }
}
-Depthbuffer::Depthbuffer(int width, int height, GLsizei samples) : DepthStencilbuffer(width, height, samples)
+Depthbuffer::Depthbuffer(int width, int height, GLenum internalformat, GLsizei samples) : DepthStencilbuffer(width, height, internalformat, samples)
{
- if(mDepthStencil)
- {
- format = GL_DEPTH_COMPONENT16_OES; // If the renderbuffer parameters are queried, the calling function
- // will expect one of the valid renderbuffer formats for use in
- // glRenderbufferStorage
- }
}
Depthbuffer::~Depthbuffer()
Stencilbuffer::Stencilbuffer(egl::Image *depthStencil) : DepthStencilbuffer(depthStencil)
{
- if(depthStencil)
- {
- format = GL_STENCIL_INDEX8_OES; // If the renderbuffer parameters are queried, the calling function
- // will expect one of the valid renderbuffer formats for use in
- // glRenderbufferStorage
- }
}
-Stencilbuffer::Stencilbuffer(int width, int height, GLsizei samples) : DepthStencilbuffer(width, height, samples)
+Stencilbuffer::Stencilbuffer(int width, int height, GLsizei samples) : DepthStencilbuffer(width, height, GL_STENCIL_INDEX8_OES, samples)
{
- if(mDepthStencil)
- {
- format = GL_STENCIL_INDEX8_OES; // If the renderbuffer parameters are queried, the calling function
- // will expect one of the valid renderbuffer formats for use in
- // glRenderbufferStorage
- }
}
Stencilbuffer::~Stencilbuffer()
virtual GLsizei getWidth() const = 0;
virtual GLsizei getHeight() const = 0;
virtual GLenum getFormat() const = 0;
- virtual sw::Format getInternalFormat() const = 0;
virtual GLsizei getSamples() const = 0;
GLuint getRedSize() const;
virtual GLsizei getWidth() const;
virtual GLsizei getHeight() const;
virtual GLenum getFormat() const;
- virtual sw::Format getInternalFormat() const;
virtual GLsizei getSamples() const;
private:
virtual GLsizei getWidth() const;
virtual GLsizei getHeight() const;
virtual GLenum getFormat() const;
- virtual sw::Format getInternalFormat() const;
virtual GLsizei getSamples() const;
protected:
GLsizei mWidth;
GLsizei mHeight;
GLenum format;
- sw::Format internalFormat;
GLsizei mSamples;
};
GLsizei getWidth() const;
GLsizei getHeight() const;
GLenum getFormat() const;
- sw::Format getInternalFormat() const;
GLuint getRedSize() const;
GLuint getGreenSize() const;
GLuint getBlueSize() const;
{
public:
explicit Colorbuffer(egl::Image *renderTarget);
- Colorbuffer(GLsizei width, GLsizei height, GLenum format, GLsizei samples);
+ Colorbuffer(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
virtual ~Colorbuffer();
{
public:
explicit DepthStencilbuffer(egl::Image *depthStencil);
- DepthStencilbuffer(GLsizei width, GLsizei height, GLsizei samples);
+ DepthStencilbuffer(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
~DepthStencilbuffer();
{
public:
explicit Depthbuffer(egl::Image *depthStencil);
- Depthbuffer(GLsizei width, GLsizei height, GLsizei samples);
+ Depthbuffer(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
virtual ~Depthbuffer();
};
return image;
}
-void Texture::setImage(egl::Context *context, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image)
+void Texture::setImage(GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image)
{
if(pixels && image)
{
- egl::PixelStorageModes unpackParameters;
+ gl::PixelStorageModes unpackParameters;
unpackParameters.alignment = unpackAlignment;
- image->loadImageData(context, 0, 0, 0, image->getWidth(), image->getHeight(), 1, format, type, unpackParameters, pixels);
+ image->loadImageData(0, 0, 0, image->getWidth(), image->getHeight(), 1, format, type, unpackParameters, pixels);
}
}
void Texture::setCompressedImage(GLsizei imageSize, const void *pixels, egl::Image *image)
{
- if(pixels && image && (imageSize > 0)) // imageSize's correlation to width and height is already validated with egl::ComputeCompressedSize() at the API level
+ if(pixels && image && (imageSize > 0)) // imageSize's correlation to width and height is already validated with gl::ComputeCompressedSize() at the API level
{
image->loadCompressedData(0, 0, 0, image->getWidth(), image->getHeight(), 1, imageSize, pixels);
}
}
-void Texture::subImage(egl::Context *context, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image)
+void Texture::subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image)
{
if(!image)
{
if(pixels)
{
- egl::PixelStorageModes unpackParameters;
+ gl::PixelStorageModes unpackParameters;
unpackParameters.alignment = unpackAlignment;
- image->loadImageData(context, xoffset, yoffset, 0, width, height, 1, format, type, unpackParameters, pixels);
+ image->loadImageData(xoffset, yoffset, 0, width, height, 1, format, type, unpackParameters, pixels);
}
}
return error(GL_INVALID_OPERATION);
}
- if(pixels && (imageSize > 0)) // imageSize's correlation to width and height is already validated with egl::ComputeCompressedSize() at the API level
+ if(pixels && (imageSize > 0)) // imageSize's correlation to width and height is already validated with gl::ComputeCompressedSize() at the API level
{
image->loadCompressedData(xoffset, yoffset, 0, width, height, 1, imageSize, pixels);
}
return image[level] ? image[level]->getHeight() : 0;
}
-GLenum Texture2D::getFormat(GLenum target, GLint level) const
+GLint Texture2D::getFormat(GLenum target, GLint level) const
{
ASSERT(target == GL_TEXTURE_2D);
return image[level] ? image[level]->getFormat() : GL_NONE;
}
-GLenum Texture2D::getType(GLenum target, GLint level) const
-{
- ASSERT(target == GL_TEXTURE_2D);
- return image[level] ? image[level]->getType() : GL_NONE;
-}
-
sw::Format Texture2D::getInternalFormat(GLenum target, GLint level) const
{
ASSERT(target == GL_TEXTURE_2D);
return level - 1;
}
-void Texture2D::setImage(egl::Context *context, GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels)
+void Texture2D::setImage(GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels)
{
if(image[level])
{
image[level]->release();
}
- image[level] = egl::Image::create(this, width, height, format, type);
+ image[level] = egl::Image::create(this, width, height, internalformat);
if(!image[level])
{
return error(GL_OUT_OF_MEMORY);
}
- Texture::setImage(context, format, type, unpackAlignment, pixels, image[level]);
+ Texture::setImage(format, type, unpackAlignment, pixels, image[level]);
}
void Texture2D::bindTexImage(gl::Surface *surface)
{
- switch(surface->getInternalFormat())
- {
- case sw::FORMAT_A8R8G8B8:
- case sw::FORMAT_A8B8G8R8:
- case sw::FORMAT_X8B8G8R8:
- case sw::FORMAT_X8R8G8B8:
- break;
- default:
- UNIMPLEMENTED();
- return;
- }
-
for(int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
if(image[level])
image[level]->release();
}
- image[level] = egl::Image::create(this, width, height, format, GL_UNSIGNED_BYTE);
+ image[level] = egl::Image::create(this, width, height, format);
if(!image[level])
{
Texture::setCompressedImage(imageSize, pixels, image[level]);
}
-void Texture2D::subImage(egl::Context *context, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels)
+void Texture2D::subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels)
{
- Texture::subImage(context, xoffset, yoffset, width, height, format, type, unpackAlignment, pixels, image[level]);
+ Texture::subImage(xoffset, yoffset, width, height, format, type, unpackAlignment, pixels, image[level]);
}
void Texture2D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
image[level]->release();
}
- image[level] = egl::Image::create(this, width, height, format, GL_UNSIGNED_BYTE);
+ image[level] = egl::Image::create(this, width, height, format);
if(!image[level])
{
return false;
}
- if(image[level]->getType() != image[0]->getType())
- {
- return false;
- }
-
if(image[level]->getWidth() != std::max(1, width >> level))
{
return false;
image[i]->release();
}
- image[i] = egl::Image::create(this, std::max(image[0]->getWidth() >> i, 1), std::max(image[0]->getHeight() >> i, 1), image[0]->getFormat(), image[0]->getType());
+ image[i] = egl::Image::create(this, std::max(image[0]->getWidth() >> i, 1), std::max(image[0]->getHeight() >> i, 1), image[0]->getFormat());
if(!image[i])
{
virtual GLsizei getWidth(GLenum target, GLint level) const = 0;
virtual GLsizei getHeight(GLenum target, GLint level) const = 0;
- virtual GLenum getFormat(GLenum target, GLint level) const = 0;
- virtual GLenum getType(GLenum target, GLint level) const = 0;
+ virtual GLint getFormat(GLenum target, GLint level) const = 0;
virtual sw::Format getInternalFormat(GLenum target, GLint level) const = 0;
virtual int getTopLevel() const = 0;
protected:
~Texture() override;
- void setImage(egl::Context *context, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image);
- void subImage(egl::Context *context, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image);
+ void setImage(GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image);
+ void subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image);
void setCompressedImage(GLsizei imageSize, const void *pixels, egl::Image *image);
void subImageCompressed(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels, egl::Image *image);
GLsizei getWidth(GLenum target, GLint level) const override;
GLsizei getHeight(GLenum target, GLint level) const override;
- GLenum getFormat(GLenum target, GLint level) const override;
- GLenum getType(GLenum target, GLint level) const override;
+ GLint getFormat(GLenum target, GLint level) const override;
sw::Format getInternalFormat(GLenum target, GLint level) const override;
int getTopLevel() const override;
- void setImage(egl::Context *context, GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
+ void setImage(GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
- void subImage(egl::Context *context, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
+ void subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
void copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
return error(GL_INVALID_ENUM);
}
- if(imageSize != egl::ComputeCompressedSize(width, height, internalformat))
+ if(imageSize != gl::ComputeCompressedSize(width, height, internalformat))
{
return error(GL_INVALID_VALUE);
}
if(context)
{
- if(imageSize != egl::ComputeCompressedSize(width, height, format))
+ if(imageSize != gl::ComputeCompressedSize(width, height, format))
{
return error(GL_INVALID_VALUE);
}
es1::Renderbuffer *source = framebuffer->getColorbuffer();
GLenum colorbufferFormat = source->getFormat();
- // [OpenGL ES 2.0.24] table 3.9
+ // [OpenGL ES 1.1.12] table 3.9
switch(internalformat)
{
case GL_ALPHA:
return error(GL_INVALID_ENUM);
}
+ // Determine the sized internal format.
+ if(gl::GetBaseInternalFormat(colorbufferFormat) == internalformat)
+ {
+ internalformat = colorbufferFormat;
+ }
+ else if(GetRedSize(colorbufferFormat) == 8)
+ {
+ internalformat = gl::GetSizedInternalFormat(internalformat, GL_UNSIGNED_BYTE);
+ }
+ else
+ {
+ UNIMPLEMENTED();
+
+ return error(GL_INVALID_OPERATION);
+ }
+
if(target == GL_TEXTURE_2D)
{
es1::Texture2D *texture = context->getTexture2D();
{
case GL_RENDERBUFFER_WIDTH_OES: *params = renderbuffer->getWidth(); break;
case GL_RENDERBUFFER_HEIGHT_OES: *params = renderbuffer->getHeight(); break;
- case GL_RENDERBUFFER_INTERNAL_FORMAT_OES: *params = renderbuffer->getFormat(); break;
+ case GL_RENDERBUFFER_INTERNAL_FORMAT_OES:
+ {
+ GLint internalformat = renderbuffer->getFormat();
+ *params = (internalformat == GL_NONE) ? GL_RGBA4_OES : internalformat;
+ }
+ break;
case GL_RENDERBUFFER_RED_SIZE_OES: *params = renderbuffer->getRedSize(); break;
case GL_RENDERBUFFER_GREEN_SIZE_OES: *params = renderbuffer->getGreenSize(); break;
case GL_RENDERBUFFER_BLUE_SIZE_OES: *params = renderbuffer->getBlueSize(); break;
switch(internalformat)
{
- case GL_DEPTH_COMPONENT16_OES:
- context->setRenderbufferStorage(new es1::Depthbuffer(width, height, 0));
- break;
case GL_RGBA4_OES:
case GL_RGB5_A1_OES:
case GL_RGB565_OES:
case GL_RGBA8_OES:
context->setRenderbufferStorage(new es1::Colorbuffer(width, height, internalformat, 0));
break;
+ case GL_DEPTH_COMPONENT16_OES:
+ context->setRenderbufferStorage(new es1::Depthbuffer(width, height, internalformat, 0));
+ break;
case GL_STENCIL_INDEX8_OES:
context->setRenderbufferStorage(new es1::Stencilbuffer(width, height, 0));
break;
case GL_DEPTH24_STENCIL8_OES:
- context->setRenderbufferStorage(new es1::DepthStencilbuffer(width, height, 0));
+ context->setRenderbufferStorage(new es1::DepthStencilbuffer(width, height, internalformat, 0));
break;
default:
return error(GL_INVALID_ENUM);
return error(GL_INVALID_VALUE);
}
+ GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalformat, type);
+
es1::Context *context = es1::getContext();
if(context)
return error(GL_INVALID_OPERATION);
}
- texture->setImage(context, level, width, height, format, type, context->getUnpackAlignment(), pixels);
+ texture->setImage(level, width, height, sizedInternalFormat, format, type, context->getUnpackAlignment(), pixels);
}
else UNREACHABLE(target);
}
if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))
{
- texture->subImage(context, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
+ texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
}
}
else UNREACHABLE(target);
return false;
}
+ GLuint GetAlphaSize(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ case GL_NONE: return 0;
+ case GL_RGBA4: return 4;
+ case GL_RGB5_A1: return 1;
+ case GL_RGB565: return 0;
+ case GL_R8: return 0;
+ case GL_RG8: return 0;
+ case GL_RGB8: return 0;
+ case GL_RGBA8: return 8;
+ case GL_R16F: return 0;
+ case GL_RG16F: return 0;
+ case GL_RGB16F: return 0;
+ case GL_RGBA16F: return 16;
+ case GL_R32F: return 0;
+ case GL_RG32F: return 0;
+ case GL_RGB32F: return 0;
+ case GL_RGBA32F: return 32;
+ case GL_BGRA8_EXT: return 8;
+ case GL_R8UI: return 0;
+ case GL_R8I: return 0;
+ case GL_R16UI: return 0;
+ case GL_R16I: return 0;
+ case GL_R32UI: return 0;
+ case GL_R32I: return 0;
+ case GL_RG8UI: return 0;
+ case GL_RG8I: return 0;
+ case GL_RG16UI: return 0;
+ case GL_RG16I: return 0;
+ case GL_RG32UI: return 0;
+ case GL_RG32I: return 0;
+ case GL_SRGB8_ALPHA8: return 8;
+ case GL_RGB10_A2: return 2;
+ case GL_RGBA8UI: return 8;
+ case GL_RGBA8I: return 8;
+ case GL_RGB10_A2UI: return 2;
+ case GL_RGBA16UI: return 16;
+ case GL_RGBA16I: return 16;
+ case GL_RGBA32I: return 32;
+ case GL_RGBA32UI: return 32;
+ case GL_R11F_G11F_B10F: return 0;
+ default:
+ // UNREACHABLE(internalformat);
+ return 0;
+ }
+ }
+
+ GLuint GetRedSize(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ case GL_NONE: return 0;
+ case GL_RGBA4: return 4;
+ case GL_RGB5_A1: return 5;
+ case GL_RGB565: return 5;
+ case GL_R8: return 8;
+ case GL_RG8: return 8;
+ case GL_RGB8: return 8;
+ case GL_RGBA8: return 8;
+ case GL_R16F: return 16;
+ case GL_RG16F: return 16;
+ case GL_RGB16F: return 16;
+ case GL_RGBA16F: return 16;
+ case GL_R32F: return 32;
+ case GL_RG32F: return 32;
+ case GL_RGB32F: return 32;
+ case GL_RGBA32F: return 32;
+ case GL_BGRA8_EXT: return 8;
+ case GL_R8UI: return 8;
+ case GL_R8I: return 8;
+ case GL_R16UI: return 16;
+ case GL_R16I: return 16;
+ case GL_R32UI: return 32;
+ case GL_R32I: return 32;
+ case GL_RG8UI: return 8;
+ case GL_RG8I: return 8;
+ case GL_RG16UI: return 16;
+ case GL_RG16I: return 16;
+ case GL_RG32UI: return 32;
+ case GL_RG32I: return 32;
+ case GL_SRGB8_ALPHA8: return 8;
+ case GL_RGB10_A2: return 10;
+ case GL_RGBA8UI: return 8;
+ case GL_RGBA8I: return 8;
+ case GL_RGB10_A2UI: return 10;
+ case GL_RGBA16UI: return 16;
+ case GL_RGBA16I: return 16;
+ case GL_RGBA32I: return 32;
+ case GL_RGBA32UI: return 32;
+ case GL_R11F_G11F_B10F: return 11;
+ default:
+ // UNREACHABLE(internalformat);
+ return 0;
+ }
+ }
+
+ GLuint GetGreenSize(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ case GL_NONE: return 0;
+ case GL_RGBA4: return 4;
+ case GL_RGB5_A1: return 5;
+ case GL_RGB565: return 6;
+ case GL_R8: return 0;
+ case GL_RG8: return 8;
+ case GL_RGB8: return 8;
+ case GL_RGBA8: return 8;
+ case GL_R16F: return 0;
+ case GL_RG16F: return 16;
+ case GL_RGB16F: return 16;
+ case GL_RGBA16F: return 16;
+ case GL_R32F: return 0;
+ case GL_RG32F: return 32;
+ case GL_RGB32F: return 32;
+ case GL_RGBA32F: return 32;
+ case GL_BGRA8_EXT: return 8;
+ case GL_R8UI: return 0;
+ case GL_R8I: return 0;
+ case GL_R16UI: return 0;
+ case GL_R16I: return 0;
+ case GL_R32UI: return 0;
+ case GL_R32I: return 0;
+ case GL_RG8UI: return 8;
+ case GL_RG8I: return 8;
+ case GL_RG16UI: return 16;
+ case GL_RG16I: return 16;
+ case GL_RG32UI: return 32;
+ case GL_RG32I: return 32;
+ case GL_SRGB8_ALPHA8: return 8;
+ case GL_RGB10_A2: return 10;
+ case GL_RGBA8UI: return 8;
+ case GL_RGBA8I: return 8;
+ case GL_RGB10_A2UI: return 10;
+ case GL_RGBA16UI: return 16;
+ case GL_RGBA16I: return 16;
+ case GL_RGBA32I: return 32;
+ case GL_RGBA32UI: return 32;
+ case GL_R11F_G11F_B10F: return 11;
+ default:
+ // UNREACHABLE(internalformat);
+ return 0;
+ }
+ }
+
+ GLuint GetBlueSize(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ case GL_NONE: return 0;
+ case GL_RGBA4: return 4;
+ case GL_RGB5_A1: return 5;
+ case GL_RGB565: return 5;
+ case GL_R8: return 0;
+ case GL_RG8: return 0;
+ case GL_RGB8: return 8;
+ case GL_RGBA8: return 8;
+ case GL_R16F: return 0;
+ case GL_RG16F: return 0;
+ case GL_RGB16F: return 16;
+ case GL_RGBA16F: return 16;
+ case GL_R32F: return 0;
+ case GL_RG32F: return 0;
+ case GL_RGB32F: return 32;
+ case GL_RGBA32F: return 32;
+ case GL_BGRA8_EXT: return 8;
+ case GL_R8UI: return 0;
+ case GL_R8I: return 0;
+ case GL_R16UI: return 0;
+ case GL_R16I: return 0;
+ case GL_R32UI: return 0;
+ case GL_R32I: return 0;
+ case GL_RG8UI: return 0;
+ case GL_RG8I: return 0;
+ case GL_RG16UI: return 0;
+ case GL_RG16I: return 0;
+ case GL_RG32UI: return 0;
+ case GL_RG32I: return 0;
+ case GL_SRGB8_ALPHA8: return 8;
+ case GL_RGB10_A2: return 10;
+ case GL_RGBA8UI: return 8;
+ case GL_RGBA8I: return 8;
+ case GL_RGB10_A2UI: return 10;
+ case GL_RGBA16UI: return 16;
+ case GL_RGBA16I: return 16;
+ case GL_RGBA32I: return 32;
+ case GL_RGBA32UI: return 32;
+ case GL_R11F_G11F_B10F: return 10;
+ default:
+ // UNREACHABLE(internalformat);
+ return 0;
+ }
+ }
+
+ GLuint GetDepthSize(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ case GL_STENCIL_INDEX8: return 0;
+ case GL_DEPTH_COMPONENT16: return 16;
+ case GL_DEPTH_COMPONENT24: return 24;
+ case GL_DEPTH_COMPONENT32_OES: return 32;
+ case GL_DEPTH_COMPONENT32F: return 32;
+ case GL_DEPTH24_STENCIL8: return 24;
+ case GL_DEPTH32F_STENCIL8: return 32;
+ default:
+ // UNREACHABLE(internalformat);
+ return 0;
+ }
+ }
+
+ GLuint GetStencilSize(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ case GL_STENCIL_INDEX8: return 8;
+ case GL_DEPTH_COMPONENT16: return 0;
+ case GL_DEPTH_COMPONENT24: return 0;
+ case GL_DEPTH_COMPONENT32_OES: return 0;
+ case GL_DEPTH_COMPONENT32F: return 0;
+ case GL_DEPTH24_STENCIL8: return 8;
+ case GL_DEPTH32F_STENCIL8: return 8;
+ default:
+ // UNREACHABLE(internalformat);
+ return 0;
+ }
+ }
+
bool IsAlpha(GLenum texFormat)
{
switch(texFormat)
namespace sw2es
{
- unsigned int GetStencilSize(sw::Format stencilFormat)
- {
- switch(stencilFormat)
- {
- case sw::FORMAT_D24FS8:
- case sw::FORMAT_D24S8:
- case sw::FORMAT_D32FS8_TEXTURE:
- return 8;
- // case sw::FORMAT_D24X4S4:
- // return 4;
- // case sw::FORMAT_D15S1:
- // return 1;
- // case sw::FORMAT_D16_LOCKABLE:
- case sw::FORMAT_D32:
- case sw::FORMAT_D24X8:
- case sw::FORMAT_D32F_LOCKABLE:
- case sw::FORMAT_D16:
- return 0;
- // case sw::FORMAT_D32_LOCKABLE: return 0;
- // case sw::FORMAT_S8_LOCKABLE: return 8;
- default:
- return 0;
- }
- }
-
- unsigned int GetAlphaSize(sw::Format colorFormat)
- {
- switch(colorFormat)
- {
- case sw::FORMAT_A16B16G16R16F:
- return 16;
- case sw::FORMAT_A32B32G32R32F:
- return 32;
- case sw::FORMAT_A2R10G10B10:
- return 2;
- case sw::FORMAT_A8R8G8B8:
- case sw::FORMAT_A8B8G8R8:
- return 8;
- case sw::FORMAT_A1R5G5B5:
- return 1;
- case sw::FORMAT_X8R8G8B8:
- case sw::FORMAT_X8B8G8R8:
- case sw::FORMAT_R5G6B5:
- return 0;
- default:
- return 0;
- }
- }
-
- unsigned int GetRedSize(sw::Format colorFormat)
- {
- switch(colorFormat)
- {
- case sw::FORMAT_A16B16G16R16F:
- return 16;
- case sw::FORMAT_A32B32G32R32F:
- return 32;
- case sw::FORMAT_A2R10G10B10:
- return 10;
- case sw::FORMAT_A8R8G8B8:
- case sw::FORMAT_A8B8G8R8:
- case sw::FORMAT_X8R8G8B8:
- case sw::FORMAT_X8B8G8R8:
- return 8;
- case sw::FORMAT_A1R5G5B5:
- case sw::FORMAT_R5G6B5:
- return 5;
- default:
- return 0;
- }
- }
-
- unsigned int GetGreenSize(sw::Format colorFormat)
- {
- switch(colorFormat)
- {
- case sw::FORMAT_A16B16G16R16F:
- return 16;
- case sw::FORMAT_A32B32G32R32F:
- return 32;
- case sw::FORMAT_A2R10G10B10:
- return 10;
- case sw::FORMAT_A8R8G8B8:
- case sw::FORMAT_A8B8G8R8:
- case sw::FORMAT_X8R8G8B8:
- case sw::FORMAT_X8B8G8R8:
- return 8;
- case sw::FORMAT_A1R5G5B5:
- return 5;
- case sw::FORMAT_R5G6B5:
- return 6;
- default:
- return 0;
- }
- }
-
- unsigned int GetBlueSize(sw::Format colorFormat)
- {
- switch(colorFormat)
- {
- case sw::FORMAT_A16B16G16R16F:
- return 16;
- case sw::FORMAT_A32B32G32R32F:
- return 32;
- case sw::FORMAT_A2R10G10B10:
- return 10;
- case sw::FORMAT_A8R8G8B8:
- case sw::FORMAT_A8B8G8R8:
- case sw::FORMAT_X8R8G8B8:
- case sw::FORMAT_X8B8G8R8:
- return 8;
- case sw::FORMAT_A1R5G5B5:
- case sw::FORMAT_R5G6B5:
- return 5;
- default:
- return 0;
- }
- }
-
- unsigned int GetDepthSize(sw::Format depthFormat)
- {
- switch(depthFormat)
- {
- // case sw::FORMAT_D16_LOCKABLE: return 16;
- case sw::FORMAT_D32: return 32;
- // case sw::FORMAT_D15S1: return 15;
- case sw::FORMAT_D24S8: return 24;
- case sw::FORMAT_D24X8: return 24;
- // case sw::FORMAT_D24X4S4: return 24;
- case sw::FORMAT_D16: return 16;
- case sw::FORMAT_D32F_LOCKABLE: return 32;
- case sw::FORMAT_D24FS8: return 24;
- // case sw::FORMAT_D32_LOCKABLE: return 32;
- // case sw::FORMAT_S8_LOCKABLE: return 0;
- case sw::FORMAT_D32FS8_TEXTURE: return 32;
- default: return 0;
- }
- }
-
GLenum ConvertBackBufferFormat(sw::Format format)
{
switch(format)
bool IsDepthRenderable(GLenum internalformat);
bool IsStencilRenderable(GLenum internalformat);
+ GLuint GetAlphaSize(GLint internalformat);
+ GLuint GetRedSize(GLint internalformat);
+ GLuint GetGreenSize(GLint internalformat);
+ GLuint GetBlueSize(GLint internalformat);
+ GLuint GetDepthSize(GLint internalformat);
+ GLuint GetStencilSize(GLint internalformat);
+
bool IsAlpha(GLenum texFormat);
bool IsRGB(GLenum texFormat);
bool IsRGBA(GLenum texFormat);
sw::MipmapType ConvertMipMapFilter(GLenum minFilter);
sw::FilterType ConvertTextureFilter(GLenum minFilter, GLenum magFilter, float maxAnisotropy);
bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount, GLenum elementType, sw::DrawType &swPrimitiveType, int &primitiveCount);
- sw::Format ConvertRenderbufferFormat(GLenum format);
sw::TextureStage::StageOperation ConvertCombineOperation(GLenum operation);
sw::TextureStage::SourceArgument ConvertSourceArgument(GLenum argument);
sw::TextureStage::ArgumentModifier ConvertSourceOperand(GLenum operand);
namespace sw2es
{
- GLuint GetAlphaSize(sw::Format colorFormat);
- GLuint GetRedSize(sw::Format colorFormat);
- GLuint GetGreenSize(sw::Format colorFormat);
- GLuint GetBlueSize(sw::Format colorFormat);
- GLuint GetDepthSize(sw::Format depthFormat);
- GLuint GetStencilSize(sw::Format stencilFormat);
-
GLenum ConvertBackBufferFormat(sw::Format format);
GLenum ConvertDepthStencilFormat(sw::Format format);
}
mState.unpackParameters.alignment = alignment;
}
-const egl::PixelStorageModes &Context::getUnpackParameters() const
+const gl::PixelStorageModes &Context::getUnpackParameters() const
{
return mState.unpackParameters;
}
GLsizei Context::getRequiredBufferSize(GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type) const
{
GLsizei inputWidth = (mState.unpackParameters.rowLength == 0) ? width : mState.unpackParameters.rowLength;
- GLsizei inputPitch = egl::ComputePitch(inputWidth, format, type, mState.unpackParameters.alignment);
+ GLsizei inputPitch = gl::ComputePitch(inputWidth, format, type, mState.unpackParameters.alignment);
GLsizei inputHeight = (mState.unpackParameters.imageHeight == 0) ? height : mState.unpackParameters.imageHeight;
return inputPitch * inputHeight * depth;
}
}
GLsizei outputWidth = (mState.packParameters.rowLength > 0) ? mState.packParameters.rowLength : width;
- GLsizei outputPitch = egl::ComputePitch(outputWidth, format, type, mState.packParameters.alignment);
+ GLsizei outputPitch = gl::ComputePitch(outputWidth, format, type, mState.packParameters.alignment);
GLsizei outputHeight = (mState.packParameters.imageHeight == 0) ? height : mState.packParameters.imageHeight;
pixels = getPixelPackBuffer() ? (unsigned char*)getPixelPackBuffer()->data() + (ptrdiff_t)pixels : (unsigned char*)pixels;
- pixels = ((char*)pixels) + egl::ComputePackingOffset(format, type, outputWidth, outputHeight, mState.packParameters);
+ pixels = ((char*)pixels) + gl::ComputePackingOffset(format, type, outputWidth, outputHeight, mState.packParameters);
// Sized query sanity check
if(bufSize)
sw::Rect dstRect(0, 0, width, height);
rect.clip(0.0f, 0.0f, (float)renderTarget->getWidth(), (float)renderTarget->getHeight());
- sw::Surface *externalSurface = sw::Surface::create(width, height, 1, egl::ConvertFormatType(format, type), pixels, outputPitch, outputPitch * outputHeight);
+ sw::Surface *externalSurface = sw::Surface::create(width, height, 1, gl::ConvertReadFormatType(format, type), pixels, outputPitch, outputPitch * outputHeight);
sw::SliceRectF sliceRect(rect);
sw::SliceRect dstSliceRect(dstRect);
device->blit(renderTarget, sliceRect, externalSurface, dstSliceRect, false, false, false);
gl::BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][MAX_COMBINED_TEXTURE_IMAGE_UNITS];
gl::BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];
- egl::PixelStorageModes unpackParameters;
- egl::PixelStorageModes packParameters;
+ gl::PixelStorageModes unpackParameters;
+ gl::PixelStorageModes packParameters;
};
class [[clang::lto_visibility_public]] Context : public egl::Context
void setUnpackSkipPixels(GLint skipPixels);
void setUnpackSkipRows(GLint skipRows);
void setUnpackSkipImages(GLint skipImages);
- const egl::PixelStorageModes &getUnpackParameters() const;
+ const gl::PixelStorageModes &getUnpackParameters() const;
void setPackAlignment(GLint alignment);
void setPackRowLength(GLint rowLength);
stencilBuffer->clearStencil(stencil, mask, clearRect.x0, clearRect.y0, clearRect.width(), clearRect.height());
}
- egl::Image *Device::createDepthStencilSurface(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard)
- {
- ASSERT(sw::Surface::isDepth(format) || sw::Surface::isStencil(format));
-
- if(height > OUTLINE_RESOLUTION)
- {
- ERR("Invalid parameters: %dx%d", width, height);
- return nullptr;
- }
-
- bool lockable = !sw::Surface::hasQuadLayout(format);
- egl::Image *surface = egl::Image::create(width, height, format, multiSampleDepth, lockable);
-
- if(!surface)
- {
- ERR("Out of memory");
- return nullptr;
- }
-
- return surface;
- }
-
- egl::Image *Device::createRenderTarget(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool lockable)
- {
- if(height > OUTLINE_RESOLUTION)
- {
- ERR("Invalid parameters: %dx%d", width, height);
- return nullptr;
- }
-
- egl::Image *surface = egl::Image::create(width, height, format, multiSampleDepth, lockable);
-
- if(!surface)
- {
- ERR("Out of memory");
- return nullptr;
- }
-
- return surface;
- }
-
void Device::drawIndexedPrimitive(sw::DrawType type, unsigned int indexOffset, unsigned int primitiveCount)
{
if(!bindResources() || !primitiveCount)
void clearColor(float red, float green, float blue, float alpha, unsigned int rgbaMask);
void clearDepth(float z);
void clearStencil(unsigned int stencil, unsigned int mask);
- egl::Image *createDepthStencilSurface(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool discard);
- egl::Image *createRenderTarget(unsigned int width, unsigned int height, sw::Format format, int multiSampleDepth, bool lockable);
void drawIndexedPrimitive(sw::DrawType type, unsigned int indexOffset, unsigned int primitiveCount);
void drawPrimitive(sw::DrawType type, unsigned int primiveCount);
void setPixelShader(const sw::PixelShader *shader);
switch(colorbuffer->getFormat())
{
case GL_BGRA8_EXT: return GL_BGRA_EXT;
- case GL_BGRA4_ANGLE: return GL_BGRA_EXT;
- case GL_BGR5_A1_ANGLE: return GL_BGRA_EXT;
case GL_RGBA4: return GL_RGBA;
case GL_RGB5_A1: return GL_RGBA;
case GL_RGBA8: return GL_RGBA;
switch(colorbuffer->getFormat())
{
case GL_BGRA8_EXT: return GL_UNSIGNED_BYTE;
- case GL_BGRA4_ANGLE: return GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT;
- case GL_BGR5_A1_ANGLE: return GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT;
case GL_RGBA4: return GL_UNSIGNED_SHORT_4_4_4_4;
case GL_RGB5_A1: return GL_UNSIGNED_SHORT_5_5_5_1;
case GL_RGBA8: return GL_UNSIGNED_BYTE;
{
renderTarget->addRef();
- sw::Format implementationFormat = renderTarget->getInternalFormat();
- format = sw2es::ConvertBackBufferFormat(implementationFormat);
-
mWidth = renderTarget->getWidth();
mHeight = renderTarget->getHeight();
+ format = renderTarget->getFormat();
mSamples = renderTarget->getDepth() & ~1;
}
}
Colorbuffer::Colorbuffer(int width, int height, GLenum internalformat, GLsizei samples) : mRenderTarget(nullptr)
{
- Device *device = getDevice();
-
- sw::Format implementationFormat = es2sw::ConvertRenderbufferFormat(internalformat);
int supportedSamples = Context::getSupportedMultisampleCount(samples);
if(width > 0 && height > 0)
{
- mRenderTarget = device->createRenderTarget(width, height, implementationFormat, supportedSamples, false);
+ if(height > sw::OUTLINE_RESOLUTION)
+ {
+ error(GL_OUT_OF_MEMORY);
+ return;
+ }
+
+ mRenderTarget = egl::Image::create(width, height, internalformat, supportedSamples, false);
if(!mRenderTarget)
{
{
depthStencil->addRef();
- sw::Format implementationFormat = depthStencil->getInternalFormat();
- format = sw2es::ConvertDepthStencilFormat(implementationFormat);
-
mWidth = depthStencil->getWidth();
mHeight = depthStencil->getHeight();
+ format = depthStencil->getFormat();
mSamples = depthStencil->getDepth() & ~1;
}
}
DepthStencilbuffer::DepthStencilbuffer(int width, int height, GLenum internalformat, GLsizei samples) : mDepthStencil(nullptr)
{
- format = internalformat;
- sw::Format implementationFormat = sw::FORMAT_D24S8;
- switch(internalformat)
- {
- case GL_STENCIL_INDEX8: implementationFormat = sw::FORMAT_S8; break;
- case GL_DEPTH_COMPONENT24: implementationFormat = sw::FORMAT_D24X8; break;
- case GL_DEPTH24_STENCIL8_OES: implementationFormat = sw::FORMAT_D24S8; break;
- case GL_DEPTH32F_STENCIL8: implementationFormat = sw::FORMAT_D32FS8; break;
- case GL_DEPTH_COMPONENT16: implementationFormat = sw::FORMAT_D16; break;
- case GL_DEPTH_COMPONENT32_OES: implementationFormat = sw::FORMAT_D32; break;
- case GL_DEPTH_COMPONENT32F: implementationFormat = sw::FORMAT_D32F; break;
- default:
- UNREACHABLE(internalformat);
- format = GL_DEPTH24_STENCIL8_OES;
- implementationFormat = sw::FORMAT_D24S8;
- }
-
- Device *device = getDevice();
-
int supportedSamples = Context::getSupportedMultisampleCount(samples);
if(width > 0 && height > 0)
{
- mDepthStencil = device->createDepthStencilSurface(width, height, implementationFormat, supportedSamples, false);
+ if(height > sw::OUTLINE_RESOLUTION)
+ {
+ error(GL_OUT_OF_MEMORY);
+ return;
+ }
+
+ mDepthStencil = egl::Image::create(width, height, internalformat, supportedSamples, false);
if(!mDepthStencil)
{
mWidth = width;
mHeight = height;
+ format = internalformat;
mSamples = supportedSamples;
}
namespace es2
{
-// Sized internal formats corresponding to GL_BGRA_EXT/GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT and
-// GL_BGRA_EXT/GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT format/type combinations, respectively.
-const GLint GL_BGRA4_ANGLE = 0x6ABC;
-const GLint GL_BGR5_A1_ANGLE = 0x6ABD;
class Texture2D;
class Texture3D;
return image;
}
-void Texture::setImage(egl::Context *context, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image)
+void Texture::setImage(GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image)
{
if(pixels && image)
{
GLsizei depth = (getTarget() == GL_TEXTURE_3D_OES || getTarget() == GL_TEXTURE_2D_ARRAY) ? image->getDepth() : 1;
- image->loadImageData(context, 0, 0, 0, image->getWidth(), image->getHeight(), depth, format, type, unpackParameters, pixels);
+ image->loadImageData(0, 0, 0, image->getWidth(), image->getHeight(), depth, format, type, unpackParameters, pixels);
}
}
void Texture::setCompressedImage(GLsizei imageSize, const void *pixels, egl::Image *image)
{
- if(pixels && image && (imageSize > 0)) // imageSize's correlation to width and height is already validated with egl::ComputeCompressedSize() at the API level
+ if(pixels && image && (imageSize > 0)) // imageSize's correlation to width and height is already validated with gl::ComputeCompressedSize() at the API level
{
GLsizei depth = (getTarget() == GL_TEXTURE_3D_OES || getTarget() == GL_TEXTURE_2D_ARRAY) ? image->getDepth() : 1;
image->loadCompressedData(0, 0, 0, image->getWidth(), image->getHeight(), depth, imageSize, pixels);
}
}
-void Texture::subImage(egl::Context *context, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image)
+void Texture::subImage(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image)
{
if(!image)
{
if(pixels && width > 0 && height > 0 && depth > 0)
{
- image->loadImageData(context, xoffset, yoffset, zoffset, width, height, depth, format, type, unpackParameters, pixels);
+ image->loadImageData(xoffset, yoffset, zoffset, width, height, depth, format, type, unpackParameters, pixels);
}
}
return error(GL_INVALID_OPERATION);
}
- if(pixels && (imageSize > 0)) // imageSize's correlation to width and height is already validated with egl::ComputeCompressedSize() at the API level
+ if(pixels && (imageSize > 0)) // imageSize's correlation to width and height is already validated with gl::ComputeCompressedSize() at the API level
{
image->loadCompressedData(xoffset, yoffset, zoffset, width, height, depth, imageSize, pixels);
}
return image[level] ? image[level]->getFormat() : GL_NONE;
}
-GLenum Texture2D::getType(GLenum target, GLint level) const
-{
- ASSERT(target == getTarget());
- return image[level] ? image[level]->getType() : GL_NONE;
-}
-
int Texture2D::getTopLevel() const
{
ASSERT(isSamplerComplete());
return level - 1;
}
-void Texture2D::setImage(egl::Context *context, GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels)
+void Texture2D::setImage(GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels)
{
if(image[level])
{
image[level]->release();
}
- image[level] = egl::Image::create(this, width, height, internalformat, type);
+ image[level] = egl::Image::create(this, width, height, internalformat);
if(!image[level])
{
return error(GL_OUT_OF_MEMORY);
}
- Texture::setImage(context, format, type, unpackParameters, pixels, image[level]);
+ Texture::setImage(format, type, unpackParameters, pixels, image[level]);
}
void Texture2D::bindTexImage(gl::Surface *surface)
{
- switch(surface->getInternalFormat())
- {
- case sw::FORMAT_A8R8G8B8:
- case sw::FORMAT_A8B8G8R8:
- case sw::FORMAT_X8B8G8R8:
- case sw::FORMAT_X8R8G8B8:
- break;
- default:
- UNIMPLEMENTED();
- return;
- }
-
for(int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
if(image[level])
image[level]->release();
}
- GLint sizedInternalFormat = GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
- image[level] = egl::Image::create(this, width, height, sizedInternalFormat, GL_UNSIGNED_BYTE);
+ image[level] = egl::Image::create(this, width, height, format);
if(!image[level])
{
Texture::setCompressedImage(imageSize, pixels, image[level]);
}
-void Texture2D::subImage(egl::Context *context, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels)
+void Texture2D::subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels)
{
- Texture::subImage(context, xoffset, yoffset, 0, width, height, 1, format, type, unpackParameters, pixels, image[level]);
+ Texture::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpackParameters, pixels, image[level]);
}
void Texture2D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
Texture::subImageCompressed(xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels, image[level]);
}
-void Texture2D::copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source)
+void Texture2D::copyImage(GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source)
{
egl::Image *renderTarget = source->getRenderTarget();
image[level]->release();
}
- GLint sizedInternalFormat = GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
- image[level] = egl::Image::create(this, width, height, sizedInternalFormat, GL_UNSIGNED_BYTE);
+ image[level] = egl::Image::create(this, width, height, internalformat);
if(!image[level])
{
return false;
}
- if(image[level]->getType() != image[mBaseLevel]->getType())
- {
- return false;
- }
-
int i = level - mBaseLevel;
if(image[level]->getWidth() != std::max(1, width >> i))
image[i]->release();
}
- image[i] = egl::Image::create(this, std::max(image[mBaseLevel]->getWidth() >> i, 1), std::max(image[mBaseLevel]->getHeight() >> i, 1), image[mBaseLevel]->getFormat(), image[mBaseLevel]->getType());
+ image[i] = egl::Image::create(this, std::max(image[mBaseLevel]->getWidth() >> i, 1), std::max(image[mBaseLevel]->getHeight() >> i, 1), image[mBaseLevel]->getFormat());
if(!image[i])
{
return image[face][level] ? image[face][level]->getFormat() : 0;
}
-GLenum TextureCubeMap::getType(GLenum target, GLint level) const
-{
- int face = CubeFaceIndex(target);
- return image[face][level] ? image[face][level]->getType() : 0;
-}
-
int TextureCubeMap::getTopLevel() const
{
ASSERT(isSamplerComplete());
image[face][level]->release();
}
- GLint sizedInternalFormat = GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
int border = (egl::getClientVersion() >= 3) ? 1 : 0;
- image[face][level] = egl::Image::create(this, width, height, 1, border, sizedInternalFormat, GL_UNSIGNED_BYTE);
+ image[face][level] = egl::Image::create(this, width, height, 1, border, format);
if(!image[face][level])
{
Texture::setCompressedImage(imageSize, pixels, image[face][level]);
}
-void TextureCubeMap::subImage(egl::Context *context, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels)
+void TextureCubeMap::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels)
{
- Texture::subImage(context, xoffset, yoffset, 0, width, height, 1, format, type, unpackParameters, pixels, image[CubeFaceIndex(target)][level]);
+ Texture::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpackParameters, pixels, image[CubeFaceIndex(target)][level]);
}
void TextureCubeMap::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
{
if(image[face][mBaseLevel]->getWidth() != image[0][mBaseLevel]->getWidth() ||
image[face][mBaseLevel]->getWidth() != image[0][mBaseLevel]->getHeight() ||
- image[face][mBaseLevel]->getFormat() != image[0][mBaseLevel]->getFormat() ||
- image[face][mBaseLevel]->getType() != image[0][mBaseLevel]->getType())
+ image[face][mBaseLevel]->getFormat() != image[0][mBaseLevel]->getFormat())
{
return false;
}
return false;
}
- if(image[face][level]->getType() != image[0][mBaseLevel]->getType())
- {
- return false;
- }
-
int i = level - mBaseLevel;
if(image[face][level]->getWidth() != std::max(1, size >> i))
UNREACHABLE(0); // Cube maps cannot have an EGL surface bound as an image
}
-void TextureCubeMap::setImage(egl::Context *context, GLenum target, GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels)
+void TextureCubeMap::setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels)
{
int face = CubeFaceIndex(target);
}
int border = (egl::getClientVersion() >= 3) ? 1 : 0;
- image[face][level] = egl::Image::create(this, width, height, 1, border, internalformat, type);
+ image[face][level] = egl::Image::create(this, width, height, 1, border, internalformat);
if(!image[face][level])
{
return error(GL_OUT_OF_MEMORY);
}
- Texture::setImage(context, format, type, unpackParameters, pixels, image[face][level]);
+ Texture::setImage(format, type, unpackParameters, pixels, image[face][level]);
}
-void TextureCubeMap::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source)
+void TextureCubeMap::copyImage(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source)
{
egl::Image *renderTarget = source->getRenderTarget();
image[face][level]->release();
}
- GLint sizedInternalFormat = GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
int border = (egl::getClientVersion() >= 3) ? 1 : 0;
- image[face][level] = egl::Image::create(this, width, height, 1, border, sizedInternalFormat, GL_UNSIGNED_BYTE);
+ image[face][level] = egl::Image::create(this, width, height, 1, border, internalformat);
if(!image[face][level])
{
}
int border = (egl::getClientVersion() >= 3) ? 1 : 0;
- image[f][i] = egl::Image::create(this, std::max(image[f][mBaseLevel]->getWidth() >> i, 1), std::max(image[f][mBaseLevel]->getHeight() >> i, 1), 1, border, image[f][mBaseLevel]->getFormat(), image[f][mBaseLevel]->getType());
+ image[f][i] = egl::Image::create(this, std::max(image[f][mBaseLevel]->getWidth() >> i, 1), std::max(image[f][mBaseLevel]->getHeight() >> i, 1), 1, border, image[f][mBaseLevel]->getFormat());
if(!image[f][i])
{
return image[level] ? image[level]->getFormat() : GL_NONE;
}
-GLenum Texture3D::getType(GLenum target, GLint level) const
-{
- ASSERT(target == getTarget());
- return image[level] ? image[level]->getType() : GL_NONE;
-}
-
int Texture3D::getTopLevel() const
{
ASSERT(isSamplerComplete());
return level - 1;
}
-void Texture3D::setImage(egl::Context *context, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLint internalformat, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels)
+void Texture3D::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLint internalformat, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels)
{
if(image[level])
{
image[level]->release();
}
- image[level] = egl::Image::create(this, width, height, depth, 0, internalformat, type);
+ image[level] = egl::Image::create(this, width, height, depth, 0, internalformat);
if(!image[level])
{
return error(GL_OUT_OF_MEMORY);
}
- Texture::setImage(context, format, type, unpackParameters, pixels, image[level]);
+ Texture::setImage(format, type, unpackParameters, pixels, image[level]);
}
void Texture3D::releaseTexImage()
image[level]->release();
}
- GLenum sizedInternalFormat = GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
- image[level] = egl::Image::create(this, width, height, depth, 0, sizedInternalFormat, GL_UNSIGNED_BYTE);
+ image[level] = egl::Image::create(this, width, height, depth, 0, format);
if(!image[level])
{
Texture::setCompressedImage(imageSize, pixels, image[level]);
}
-void Texture3D::subImage(egl::Context *context, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels)
+void Texture3D::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels)
{
- Texture::subImage(context, xoffset, yoffset, zoffset, width, height, depth, format, type, unpackParameters, pixels, image[level]);
+ Texture::subImage(xoffset, yoffset, zoffset, width, height, depth, format, type, unpackParameters, pixels, image[level]);
}
void Texture3D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
Texture::subImageCompressed(xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels, image[level]);
}
-void Texture3D::copyImage(GLint level, GLenum format, GLint x, GLint y, GLint z, GLsizei width, GLsizei height, GLsizei depth, Renderbuffer *source)
+void Texture3D::copyImage(GLint level, GLenum internalformat, GLint x, GLint y, GLint z, GLsizei width, GLsizei height, GLsizei depth, Renderbuffer *source)
{
egl::Image *renderTarget = source->getRenderTarget();
image[level]->release();
}
- GLint sizedInternalFormat = GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
- image[level] = egl::Image::create(this, width, height, depth, 0, sizedInternalFormat, GL_UNSIGNED_BYTE);
+ image[level] = egl::Image::create(this, width, height, depth, 0, internalformat);
if(!image[level])
{
return false;
}
- if(image[level]->getType() != image[mBaseLevel]->getType())
- {
- return false;
- }
-
int i = level - mBaseLevel;
if(image[level]->getWidth() != std::max(1, width >> i))
image[i]->release();
}
- image[i] = egl::Image::create(this, std::max(image[mBaseLevel]->getWidth() >> i, 1), std::max(image[mBaseLevel]->getHeight() >> i, 1), std::max(image[mBaseLevel]->getDepth() >> i, 1), 0, image[mBaseLevel]->getFormat(), image[mBaseLevel]->getType());
+ image[i] = egl::Image::create(this, std::max(image[mBaseLevel]->getWidth() >> i, 1), std::max(image[mBaseLevel]->getHeight() >> i, 1), std::max(image[mBaseLevel]->getDepth() >> i, 1), 0, image[mBaseLevel]->getFormat());
if(!image[i])
{
GLsizei w = std::max(image[mBaseLevel]->getWidth() >> i, 1);
GLsizei h = std::max(image[mBaseLevel]->getHeight() >> i, 1);
- image[i] = egl::Image::create(this, w, h, depth, 0, image[mBaseLevel]->getFormat(), image[mBaseLevel]->getType());
+ image[i] = egl::Image::create(this, w, h, depth, 0, image[mBaseLevel]->getFormat());
if(!image[i])
{
return nullptr;
}
- return egl::Image::create(width, height, format, multiSampleDepth, false);
+ GLenum internalformat = sw2es::ConvertBackBufferFormat(format);
+
+ return egl::Image::create(width, height, internalformat, multiSampleDepth, false);
}
NO_SANITIZE_FUNCTION egl::Image *createDepthStencil(int width, int height, sw::Format format, int multiSampleDepth)
UNREACHABLE(format);
}
- egl::Image *surface = egl::Image::create(width, height, format, multiSampleDepth, lockable);
+ GLenum internalformat = sw2es::ConvertDepthStencilFormat(format);
+
+ egl::Image *surface = egl::Image::create(width, height, internalformat, multiSampleDepth, lockable);
if(!surface)
{
virtual GLsizei getHeight(GLenum target, GLint level) const = 0;
virtual GLsizei getDepth(GLenum target, GLint level) const;
virtual GLenum getFormat(GLenum target, GLint level) const = 0;
- virtual GLenum getType(GLenum target, GLint level) const = 0;
virtual int getTopLevel() const = 0;
virtual bool isSamplerComplete() const = 0;
protected:
~Texture() override;
- void setImage(egl::Context *context, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image);
- void subImage(egl::Context *context, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image);
+ void setImage(GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image);
+ void subImage(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels, egl::Image *image);
void setCompressedImage(GLsizei imageSize, const void *pixels, egl::Image *image);
void subImageCompressed(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels, egl::Image *image);
GLsizei getWidth(GLenum target, GLint level) const override;
GLsizei getHeight(GLenum target, GLint level) const override;
GLenum getFormat(GLenum target, GLint level) const override;
- GLenum getType(GLenum target, GLint level) const override;
int getTopLevel() const override;
- void setImage(egl::Context *context, GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels);
+ void setImage(GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels);
void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
- void subImage(egl::Context *context, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels);
+ void subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels);
void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
- void copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source);
+ void copyImage(GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source);
void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source) override;
void setSharedImage(egl::Image *image);
GLsizei getWidth(GLenum target, GLint level) const override;
GLsizei getHeight(GLenum target, GLint level) const override;
GLenum getFormat(GLenum target, GLint level) const override;
- GLenum getType(GLenum target, GLint level) const override;
int getTopLevel() const override;
- void setImage(egl::Context *context, GLenum target, GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels);
+ void setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels);
void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
- void subImage(egl::Context *context, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels);
+ void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels);
void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
- void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source);
+ void copyImage(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source);
void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source) override;
bool isSamplerComplete() const override;
GLsizei getHeight(GLenum target, GLint level) const override;
GLsizei getDepth(GLenum target, GLint level) const override;
GLenum getFormat(GLenum target, GLint level) const override;
- GLenum getType(GLenum target, GLint level) const override;
int getTopLevel() const override;
- void setImage(egl::Context *context, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLint internalformat, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels);
+ void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLint internalformat, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels);
void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
- void subImage(egl::Context *context, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const egl::PixelStorageModes &unpackParameters, const void *pixels);
+ void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelStorageModes &unpackParameters, const void *pixels);
void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
- void copyImage(GLint level, GLenum format, GLint x, GLint y, GLint z, GLsizei width, GLsizei height, GLsizei depth, Renderbuffer *source);
+ void copyImage(GLint level, GLenum internalformat, GLint x, GLint y, GLint z, GLsizei width, GLsizei height, GLsizei depth, Renderbuffer *source);
void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Renderbuffer *source);
void setSharedImage(egl::Image *image);
return error(GL_INVALID_ENUM);
}
- if(imageSize != egl::ComputeCompressedSize(width, height, internalformat))
+ if(imageSize != gl::ComputeCompressedSize(width, height, internalformat))
{
return error(GL_INVALID_VALUE);
}
+ GLenum validationError = context->getPixels(&data, GL_UNSIGNED_BYTE, imageSize);
+ if(validationError != GL_NONE)
+ {
+ return error(validationError);
+ }
+
if(target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE_ARB)
{
es2::Texture2D *texture = context->getTexture2D(target);
return error(GL_INVALID_OPERATION);
}
- GLenum validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
- if(validationError != GL_NONE)
- {
- return error(validationError);
- }
-
texture->setCompressedImage(level, internalformat, width, height, imageSize, data);
}
- else
+ else if(es2::IsCubemapTextureTarget(target))
{
es2::TextureCubeMap *texture = context->getTextureCubeMap();
return error(GL_INVALID_OPERATION);
}
- switch(target)
- {
- case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
- case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
- case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
- {
- GLenum validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
- if(validationError != GL_NONE)
- {
- return error(validationError);
- }
-
- texture->setCompressedImage(target, level, internalformat, width, height, imageSize, data);
- }
- break;
- default: UNREACHABLE(target);
- }
+ texture->setCompressedImage(target, level, internalformat, width, height, imageSize, data);
}
+ else UNREACHABLE(target);
}
}
return error(GL_INVALID_VALUE);
}
- if(imageSize != egl::ComputeCompressedSize(width, height, format))
+ if(imageSize != gl::ComputeCompressedSize(width, height, format))
{
return error(GL_INVALID_VALUE);
}
return error(GL_INVALID_OPERATION);
}
+ GLenum validationError = context->getPixels(&data, GL_UNSIGNED_BYTE, imageSize);
+ if(validationError != GL_NONE)
+ {
+ return error(validationError);
+ }
+
if(target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE_ARB)
{
es2::Texture2D *texture = context->getTexture2D(target);
return error(validationError);
}
- validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
- if(validationError != GL_NONE)
- {
- return error(validationError);
- }
-
texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
}
else if(es2::IsCubemapTextureTarget(target))
return error(validationError);
}
- validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
- if(validationError != GL_NONE)
- {
- return error(validationError);
- }
-
texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
else UNREACHABLE(target);
GLenum colorbufferFormat = source->getFormat();
+ // Determine the sized internal format.
+ if(gl::IsUnsizedInternalFormat(internalformat))
+ {
+ if(gl::GetBaseInternalFormat(colorbufferFormat) == internalformat)
+ {
+ internalformat = colorbufferFormat;
+ }
+ else if(GetRedSize(colorbufferFormat) == 8)
+ {
+ internalformat = gl::GetSizedInternalFormat(internalformat, GL_UNSIGNED_BYTE);
+ }
+ else
+ {
+ UNIMPLEMENTED();
+
+ return error(GL_INVALID_OPERATION);
+ }
+ }
+
if(!ValidateCopyFormats(internalformat, colorbufferFormat))
{
return;
}
}
- GLenum validationError = ValidateTextureFormatType(format, type, internalformat, context->getClientVersion());
+ GLenum validationError = ValidateTextureFormatType(format, type, internalformat, target, context->getClientVersion());
if(validationError != GL_NONE)
{
return error(validationError);
return error(GL_INVALID_ENUM);
}
- GLenum sizedInternalFormat = GetSizedInternalFormat(internalformat, type);
+ GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalformat, type);
validationError = context->getPixels(&data, type, context->getRequiredBufferSize(width, height, 1, format, type));
if(validationError != GL_NONE)
return error(GL_INVALID_OPERATION);
}
- texture->setImage(context, level, width, height, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
+ texture->setImage(level, width, height, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
}
else
{
return error(GL_INVALID_OPERATION);
}
- texture->setImage(context, target, level, width, height, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
+ texture->setImage(target, level, width, height, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
}
}
}
return error(validationError);
}
- texture->subImage(context, level, xoffset, yoffset, width, height, format, type, context->getUnpackParameters(), data);
+ texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackParameters(), data);
}
else if(es2::IsCubemapTextureTarget(target))
{
return error(validationError);
}
- texture->subImage(context, target, level, xoffset, yoffset, width, height, format, type, context->getUnpackParameters(), data);
+ texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackParameters(), data);
}
else UNREACHABLE(target);
}
return error(GL_INVALID_OPERATION);
}
- GLenum validationError = ValidateTextureFormatType(format, type, internalformat, egl::getClientVersion());
+ GLenum validationError = ValidateTextureFormatType(format, type, internalformat, target, egl::getClientVersion());
if(validationError != GL_NONE)
{
return error(validationError);
return error(validationError);
}
- GLenum sizedInternalFormat = GetSizedInternalFormat(internalformat, type);
- texture->setImage(context, level, width, height, depth, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
+ GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalformat, type);
+ texture->setImage(level, width, height, depth, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
}
}
return error(GL_INVALID_ENUM);
}
- if(!ValidateTextureFormatType(format, type, format, egl::getClientVersion()))
- {
- return;
- }
-
if((level < 0) || (level >= es2::IMPLEMENTATION_MAX_TEXTURE_LEVELS))
{
return error(GL_INVALID_VALUE);
return error(validationError);
}
- texture->subImage(context, level, xoffset, yoffset, zoffset, width, height, depth, format, type, context->getUnpackParameters(), data);
+ texture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, context->getUnpackParameters(), data);
}
}
return error(GL_INVALID_ENUM);
}
- if(imageSize != egl::ComputeCompressedSize(width, height, internalformat) * depth)
+ if(imageSize != gl::ComputeCompressedSize(width, height, internalformat) * depth)
{
return error(GL_INVALID_VALUE);
}
return error(GL_INVALID_OPERATION);
}
- GLenum validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
+ GLenum validationError = context->getPixels(&data, GL_UNSIGNED_BYTE, imageSize);
if(validationError != GL_NONE)
{
return error(GL_INVALID_ENUM);
}
- if(imageSize != egl::ComputeCompressedSize(width, height, format) * depth)
+ if(imageSize != gl::ComputeCompressedSize(width, height, format) * depth)
{
return error(GL_INVALID_VALUE);
}
return error(GL_INVALID_OPERATION);
}
- GLenum validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
+ GLenum validationError = context->getPixels(&data, GL_UNSIGNED_BYTE, imageSize);
if(validationError != GL_NONE)
{
return error(validationError);
using namespace es2;
-typedef std::pair<GLenum, GLenum> InternalFormatTypePair;
-typedef std::map<InternalFormatTypePair, GLenum> FormatMap;
-
-// A helper function to insert data into the format map with fewer characters.
-static void InsertFormatMapping(FormatMap& map, GLenum internalformat, GLenum format, GLenum type)
-{
- map[InternalFormatTypePair(internalformat, type)] = format;
-}
-
static bool validImageSize(GLint level, GLsizei width, GLsizei height)
{
if(level < 0 || level >= es2::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)
return true;
}
-static FormatMap BuildFormatMap3D()
-{
- FormatMap map;
-
- // Internal format | Format | Type
- InsertFormatMapping(map, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5);
- InsertFormatMapping(map, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4);
- InsertFormatMapping(map, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1);
- InsertFormatMapping(map, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_R8, GL_RED, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_R8_SNORM, GL_RED, GL_BYTE);
- InsertFormatMapping(map, GL_R16F, GL_RED, GL_HALF_FLOAT);
- InsertFormatMapping(map, GL_R16F, GL_RED, GL_FLOAT);
- InsertFormatMapping(map, GL_R32F, GL_RED, GL_FLOAT);
- InsertFormatMapping(map, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_R8I, GL_RED_INTEGER, GL_BYTE);
- InsertFormatMapping(map, GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT);
- InsertFormatMapping(map, GL_R16I, GL_RED_INTEGER, GL_SHORT);
- InsertFormatMapping(map, GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT);
- InsertFormatMapping(map, GL_R32I, GL_RED_INTEGER, GL_INT);
- InsertFormatMapping(map, GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RG8_SNORM, GL_RG, GL_BYTE);
- InsertFormatMapping(map, GL_RG16F, GL_RG, GL_HALF_FLOAT);
- InsertFormatMapping(map, GL_RG16F, GL_RG, GL_FLOAT);
- InsertFormatMapping(map, GL_RG32F, GL_RG, GL_FLOAT);
- InsertFormatMapping(map, GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RG8I, GL_RG_INTEGER, GL_BYTE);
- InsertFormatMapping(map, GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT);
- InsertFormatMapping(map, GL_RG16I, GL_RG_INTEGER, GL_SHORT);
- InsertFormatMapping(map, GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT);
- InsertFormatMapping(map, GL_RG32I, GL_RG_INTEGER, GL_INT);
- InsertFormatMapping(map, GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_SRGB8, GL_RGB, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGB565, GL_RGB, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5);
- InsertFormatMapping(map, GL_RGB8_SNORM, GL_RGB, GL_BYTE);
- InsertFormatMapping(map, GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV);
- InsertFormatMapping(map, GL_R11F_G11F_B10F, GL_RGB, GL_HALF_FLOAT);
- InsertFormatMapping(map, GL_R11F_G11F_B10F, GL_RGB, GL_FLOAT);
- InsertFormatMapping(map, GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV);
- InsertFormatMapping(map, GL_RGB9_E5, GL_RGB, GL_HALF_FLOAT);
- InsertFormatMapping(map, GL_RGB9_E5, GL_RGB, GL_FLOAT);
- InsertFormatMapping(map, GL_RGB16F, GL_RGB, GL_HALF_FLOAT);
- InsertFormatMapping(map, GL_RGB16F, GL_RGB, GL_FLOAT);
- InsertFormatMapping(map, GL_RGB32F, GL_RGB, GL_FLOAT);
- InsertFormatMapping(map, GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGB8I, GL_RGB_INTEGER, GL_BYTE);
- InsertFormatMapping(map, GL_RGB16UI, GL_RGB_INTEGER, GL_UNSIGNED_SHORT);
- InsertFormatMapping(map, GL_RGB16I, GL_RGB_INTEGER, GL_SHORT);
- InsertFormatMapping(map, GL_RGB32UI, GL_RGB_INTEGER, GL_UNSIGNED_INT);
- InsertFormatMapping(map, GL_RGB32I, GL_RGB_INTEGER, GL_INT);
- InsertFormatMapping(map, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1);
- InsertFormatMapping(map, GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV);
- InsertFormatMapping(map, GL_RGBA8_SNORM, GL_RGBA, GL_BYTE);
- InsertFormatMapping(map, GL_RGBA4, GL_RGBA, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4);
- InsertFormatMapping(map, GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV);
- InsertFormatMapping(map, GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT);
- InsertFormatMapping(map, GL_RGBA16F, GL_RGBA, GL_FLOAT);
- InsertFormatMapping(map, GL_RGBA32F, GL_RGBA, GL_FLOAT);
- InsertFormatMapping(map, GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE);
- InsertFormatMapping(map, GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE);
- InsertFormatMapping(map, GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV);
- InsertFormatMapping(map, GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT);
- InsertFormatMapping(map, GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT);
- InsertFormatMapping(map, GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT);
- InsertFormatMapping(map, GL_RGBA32I, GL_RGBA_INTEGER, GL_INT);
-
- InsertFormatMapping(map, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT);
- InsertFormatMapping(map, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
- InsertFormatMapping(map, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
- InsertFormatMapping(map, GL_DEPTH_COMPONENT32_OES, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
- InsertFormatMapping(map, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT);
- InsertFormatMapping(map, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
- InsertFormatMapping(map, GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
-
- return map;
-}
-
-static bool ValidateType3D(GLenum type)
-{
- switch(type)
- {
- case GL_UNSIGNED_BYTE:
- case GL_BYTE:
- case GL_UNSIGNED_SHORT:
- case GL_SHORT:
- case GL_UNSIGNED_INT:
- case GL_INT:
- case GL_HALF_FLOAT:
- case GL_FLOAT:
- case GL_UNSIGNED_SHORT_5_6_5:
- case GL_UNSIGNED_SHORT_4_4_4_4:
- case GL_UNSIGNED_SHORT_5_5_5_1:
- case GL_UNSIGNED_INT_2_10_10_10_REV:
- case GL_UNSIGNED_INT_10F_11F_11F_REV:
- case GL_UNSIGNED_INT_5_9_9_9_REV:
- case GL_UNSIGNED_INT_24_8:
- case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
- return true;
- default:
- break;
- }
- return false;
-}
-
-static bool ValidateFormat3D(GLenum format)
-{
- switch(format)
- {
- case GL_RED:
- case GL_RG:
- case GL_RGB:
- case GL_RGBA:
- case GL_DEPTH_COMPONENT:
- case GL_DEPTH_STENCIL:
- case GL_LUMINANCE_ALPHA:
- case GL_LUMINANCE:
- case GL_ALPHA:
- case GL_RED_INTEGER:
- case GL_RG_INTEGER:
- case GL_RGB_INTEGER:
- case GL_RGBA_INTEGER:
- return true;
- default:
- break;
- }
- return false;
-}
-
-static bool ValidateInternalFormat3D(GLenum internalformat, GLenum format, GLenum type)
-{
- static const FormatMap formatMap = BuildFormatMap3D();
- FormatMap::const_iterator iter = formatMap.find(InternalFormatTypePair(internalformat, type));
- if(iter != formatMap.end())
- {
- return iter->second == format;
- }
- return false;
-}
-
-typedef std::map<GLenum, GLenum> FormatMapStorage;
-
-// A helper function to insert data into the format map with fewer characters.
-static void InsertFormatStorageMapping(FormatMapStorage& map, GLenum internalformat, GLenum type)
-{
- map[internalformat] = type;
-}
-
-static FormatMapStorage BuildFormatMapStorage2D()
-{
- FormatMapStorage map;
-
- // Internal format | Type
- InsertFormatStorageMapping(map, GL_R8, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_R8_SNORM, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_R16F, GL_HALF_FLOAT);
- InsertFormatStorageMapping(map, GL_R32F, GL_FLOAT);
- InsertFormatStorageMapping(map, GL_R8UI, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_R8I, GL_BYTE);
- InsertFormatStorageMapping(map, GL_R16UI, GL_UNSIGNED_SHORT);
- InsertFormatStorageMapping(map, GL_R16I, GL_SHORT);
- InsertFormatStorageMapping(map, GL_R32UI, GL_UNSIGNED_INT);
- InsertFormatStorageMapping(map, GL_R32I, GL_INT);
- InsertFormatStorageMapping(map, GL_RG8, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_RG8_SNORM, GL_BYTE);
- InsertFormatStorageMapping(map, GL_RG16F, GL_HALF_FLOAT);
- InsertFormatStorageMapping(map, GL_RG32F, GL_FLOAT);
- InsertFormatStorageMapping(map, GL_RG8UI, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_RG8I, GL_BYTE);
- InsertFormatStorageMapping(map, GL_RG16UI, GL_UNSIGNED_SHORT);
- InsertFormatStorageMapping(map, GL_RG16I, GL_SHORT);
- InsertFormatStorageMapping(map, GL_RG32UI, GL_UNSIGNED_INT);
- InsertFormatStorageMapping(map, GL_RG32I, GL_INT);
- InsertFormatStorageMapping(map, GL_RGB8, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_SRGB8, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_RGB565, GL_UNSIGNED_SHORT_5_6_5);
- InsertFormatStorageMapping(map, GL_RGB8_SNORM, GL_BYTE);
- InsertFormatStorageMapping(map, GL_R11F_G11F_B10F, GL_UNSIGNED_INT_10F_11F_11F_REV);
- InsertFormatStorageMapping(map, GL_RGB9_E5, GL_UNSIGNED_INT_5_9_9_9_REV);
- InsertFormatStorageMapping(map, GL_RGB16F, GL_HALF_FLOAT);
- InsertFormatStorageMapping(map, GL_RGB32F, GL_FLOAT);
- InsertFormatStorageMapping(map, GL_RGB8UI, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_RGB8I, GL_BYTE);
- InsertFormatStorageMapping(map, GL_RGB16UI, GL_UNSIGNED_SHORT);
- InsertFormatStorageMapping(map, GL_RGB16I, GL_SHORT);
- InsertFormatStorageMapping(map, GL_RGB32UI, GL_UNSIGNED_INT);
- InsertFormatStorageMapping(map, GL_RGB32I, GL_INT);
- InsertFormatStorageMapping(map, GL_RGBA8, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_SRGB8_ALPHA8, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_RGBA8_SNORM, GL_BYTE);
- InsertFormatStorageMapping(map, GL_RGB5_A1, GL_UNSIGNED_SHORT_5_5_5_1);
- InsertFormatStorageMapping(map, GL_RGBA4, GL_UNSIGNED_SHORT_4_4_4_4);
- InsertFormatStorageMapping(map, GL_RGB10_A2, GL_UNSIGNED_INT_2_10_10_10_REV);
- InsertFormatStorageMapping(map, GL_RGBA16F, GL_HALF_FLOAT);
- InsertFormatStorageMapping(map, GL_RGBA32F, GL_FLOAT);
- InsertFormatStorageMapping(map, GL_RGBA8UI, GL_UNSIGNED_BYTE);
- InsertFormatStorageMapping(map, GL_RGBA8I, GL_BYTE);
- InsertFormatStorageMapping(map, GL_RGB10_A2UI, GL_UNSIGNED_INT_2_10_10_10_REV);
- InsertFormatStorageMapping(map, GL_RGBA16UI, GL_UNSIGNED_SHORT);
- InsertFormatStorageMapping(map, GL_RGBA16I, GL_SHORT);
- InsertFormatStorageMapping(map, GL_RGBA32UI, GL_UNSIGNED_INT);
- InsertFormatStorageMapping(map, GL_RGBA32I, GL_INT);
-
- InsertFormatStorageMapping(map, GL_DEPTH_COMPONENT16, GL_UNSIGNED_SHORT);
- InsertFormatStorageMapping(map, GL_DEPTH_COMPONENT24, GL_UNSIGNED_INT);
- InsertFormatStorageMapping(map, GL_DEPTH_COMPONENT32F, GL_FLOAT);
- InsertFormatStorageMapping(map, GL_DEPTH24_STENCIL8, GL_UNSIGNED_INT_24_8);
- InsertFormatStorageMapping(map, GL_DEPTH32F_STENCIL8, GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
-
- return map;
-}
-
-static bool GetStorageType(GLenum internalformat, GLenum& type)
-{
- static const FormatMapStorage formatMap = BuildFormatMapStorage2D();
- FormatMapStorage::const_iterator iter = formatMap.find(internalformat);
- if(iter != formatMap.end())
- {
- type = iter->second;
- return true;
- }
- return false;
-}
-
static bool ValidateQueryTarget(GLenum target)
{
switch(target)
return error(GL_INVALID_ENUM);
}
- if(!ValidateType3D(type) || !ValidateFormat3D(format))
- {
- return error(GL_INVALID_ENUM);
- }
-
if((level < 0) || (level >= es2::IMPLEMENTATION_MAX_TEXTURE_LEVELS))
{
return error(GL_INVALID_VALUE);
return error(GL_INVALID_VALUE);
}
- if(!ValidateInternalFormat3D(internalformat, format, type))
- {
- return error(GL_INVALID_OPERATION);
- }
-
es2::Context *context = es2::getContext();
if(context)
{
+ GLenum validationError = ValidateTextureFormatType(format, type, internalformat, target, context->getClientVersion());
+ if(validationError != GL_NONE)
+ {
+ return error(validationError);
+ }
+
es2::Texture3D *texture = (target == GL_TEXTURE_3D) ? context->getTexture3D() : context->getTexture2DArray();
if(!texture)
return error(GL_INVALID_OPERATION);
}
- GLenum validationError = context->getPixels(&data, type, context->getRequiredBufferSize(width, height, depth, format, type));
+ validationError = context->getPixels(&data, type, context->getRequiredBufferSize(width, height, depth, format, type));
if(validationError != GL_NONE)
{
return error(validationError);
}
- GLenum sizedInternalFormat = GetSizedInternalFormat(internalformat, type);
- texture->setImage(context, level, width, height, depth, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
+ GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalformat, type);
+ texture->setImage(level, width, height, depth, sizedInternalFormat, format, type, context->getUnpackParameters(), data);
}
}
return error(GL_INVALID_ENUM);
}
- if(!ValidateType3D(type) || !ValidateFormat3D(format))
- {
- return error(GL_INVALID_ENUM);
- }
-
if((level < 0) || (level >= es2::IMPLEMENTATION_MAX_TEXTURE_LEVELS))
{
return error(GL_INVALID_VALUE);
}
es2::Context *context = es2::getContext();
-
+
if(context)
{
es2::Texture3D *texture = (target == GL_TEXTURE_3D) ? context->getTexture3D() : context->getTexture2DArray();
return error(validationError);
}
- texture->subImage(context, level, xoffset, yoffset, zoffset, width, height, depth, format, type, context->getUnpackParameters(), data);
+ texture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, context->getUnpackParameters(), data);
}
}
return error(GL_INVALID_ENUM);
}
- if(imageSize != egl::ComputeCompressedSize(width, height, internalformat) * depth)
+ if(imageSize != gl::ComputeCompressedSize(width, height, internalformat) * depth)
{
return error(GL_INVALID_VALUE);
}
return error(GL_INVALID_OPERATION);
}
- GLenum validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
+ GLenum validationError = context->getPixels(&data, GL_UNSIGNED_BYTE, imageSize);
if(validationError != GL_NONE)
{
return error(validationError);
return error(GL_INVALID_ENUM);
}
- if(imageSize != egl::ComputeCompressedSize(width, height, format) * depth)
+ if(imageSize != gl::ComputeCompressedSize(width, height, format) * depth)
{
return error(GL_INVALID_VALUE);
}
return error(GL_INVALID_OPERATION);
}
- GLenum validationError = context->getPixels(&data, texture->getType(target, level), imageSize);
+ GLenum validationError = context->getPixels(&data, GL_UNSIGNED_BYTE, imageSize);
if(validationError != GL_NONE)
{
return error(validationError);
return error(GL_INVALID_OPERATION);
}
- GLenum type;
- if(!GetStorageType(internalformat, type))
+ if(!IsSizedInternalFormat(internalformat) && !IsCompressed(internalformat, egl::getClientVersion()))
{
return error(GL_INVALID_ENUM);
}
- GLenum sizedInternalFormat = GetSizedInternalFormat(internalformat, type);
es2::Context *context = es2::getContext();
{
return error(GL_INVALID_OPERATION);
}
-
+
for(int level = 0; level < levels; level++)
{
- texture->setImage(context, level, width, height, sizedInternalFormat, sizedInternalFormat, type, context->getUnpackParameters(), nullptr);
+ texture->setImage(level, width, height, internalformat, GL_NONE, GL_NONE, context->getUnpackParameters(), nullptr);
width = std::max(1, (width / 2));
height = std::max(1, (height / 2));
}
{
return error(GL_INVALID_OPERATION);
}
-
+
for(int level = 0; level < levels; level++)
{
for(int face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; face++)
{
- texture->setImage(context, face, level, width, height, sizedInternalFormat, sizedInternalFormat, type, context->getUnpackParameters(), nullptr);
+ texture->setImage(face, level, width, height, internalformat, GL_NONE, GL_NONE, context->getUnpackParameters(), nullptr);
}
width = std::max(1, (width / 2));
height = std::max(1, (height / 2));
return error(GL_INVALID_VALUE);
}
- GLenum type;
- if(!GetStorageType(internalformat, type))
+ if(!IsSizedInternalFormat(internalformat) && !IsCompressed(internalformat, egl::getClientVersion()))
{
return error(GL_INVALID_ENUM);
}
- GLenum sizedInternalFormat = GetSizedInternalFormat(internalformat, type);
es2::Context *context = es2::getContext();
{
return error(GL_INVALID_OPERATION);
}
-
+
es2::Texture3D *texture = context->getTexture3D();
if(!texture || texture->name == 0 || texture->getImmutableFormat() == GL_TRUE)
{
return error(GL_INVALID_OPERATION);
}
-
+
for(int level = 0; level < levels; level++)
{
- texture->setImage(context, level, width, height, depth, sizedInternalFormat, sizedInternalFormat, type, context->getUnpackParameters(), nullptr);
+ texture->setImage(level, width, height, depth, internalformat, GL_NONE, GL_NONE, context->getUnpackParameters(), nullptr);
width = std::max(1, (width / 2));
height = std::max(1, (height / 2));
depth = std::max(1, (depth / 2));
{
return error(GL_INVALID_OPERATION);
}
-
+
es2::Texture3D *texture = context->getTexture2DArray();
if(!texture || texture->name == 0 || texture->getImmutableFormat())
{
return error(GL_INVALID_OPERATION);
}
-
+
for(int level = 0; level < levels; level++)
{
for(int face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; face++)
{
- texture->setImage(context, level, width, height, depth, sizedInternalFormat, sizedInternalFormat, type, context->getUnpackParameters(), nullptr);
+ texture->setImage(level, width, height, depth, internalformat, GL_NONE, GL_NONE, context->getUnpackParameters(), nullptr);
}
width = std::max(1, (width / 2));
height = std::max(1, (height / 2));
namespace es2
{
- // ES2 requires that format is equal to internal format at all glTex*Image2D entry points and the implementation
- // can decide the true, sized, internal format. The ES2FormatMap determines the internal format for all valid
- // format and type combinations.
-
- typedef std::pair<GLenum, GLenum> FormatTypePair;
- typedef std::pair<FormatTypePair, GLint> FormatPair;
- typedef std::map<FormatTypePair, GLenum> FormatMap;
-
- // A helper function to insert data into the format map with fewer characters.
- static inline void InsertFormatMapping(FormatMap *map, GLenum format, GLenum type, GLint internalFormat)
- {
- map->insert(FormatPair(FormatTypePair(format, type), internalFormat));
- }
-
- FormatMap BuildFormatMap()
- {
- FormatMap map;
-
- // | Format | Type | Internal format |
- InsertFormatMapping(&map, GL_RGBA, GL_UNSIGNED_BYTE, GL_RGBA8);
- InsertFormatMapping(&map, GL_RGBA, GL_BYTE, GL_RGBA8_SNORM);
- InsertFormatMapping(&map, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, GL_RGBA4);
- InsertFormatMapping(&map, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, GL_RGB5_A1);
- InsertFormatMapping(&map, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, GL_RGB10_A2);
- InsertFormatMapping(&map, GL_RGBA, GL_FLOAT, GL_RGBA32F);
- InsertFormatMapping(&map, GL_RGBA, GL_HALF_FLOAT, GL_RGBA16F);
- InsertFormatMapping(&map, GL_RGBA, GL_HALF_FLOAT_OES, GL_RGBA16F);
-
- InsertFormatMapping(&map, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, GL_RGBA8UI);
- InsertFormatMapping(&map, GL_RGBA_INTEGER, GL_BYTE, GL_RGBA8I);
- InsertFormatMapping(&map, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, GL_RGBA16UI);
- InsertFormatMapping(&map, GL_RGBA_INTEGER, GL_SHORT, GL_RGBA16I);
- InsertFormatMapping(&map, GL_RGBA_INTEGER, GL_UNSIGNED_INT, GL_RGBA32UI);
- InsertFormatMapping(&map, GL_RGBA_INTEGER, GL_INT, GL_RGBA32I);
- InsertFormatMapping(&map, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV, GL_RGB10_A2UI);
-
- InsertFormatMapping(&map, GL_RGB, GL_UNSIGNED_BYTE, GL_RGB8);
- InsertFormatMapping(&map, GL_RGB, GL_BYTE, GL_RGB8_SNORM);
- InsertFormatMapping(&map, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, GL_RGB565);
- InsertFormatMapping(&map, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_R11F_G11F_B10F);
- InsertFormatMapping(&map, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV, GL_RGB9_E5);
- InsertFormatMapping(&map, GL_RGB, GL_FLOAT, GL_RGB32F);
- InsertFormatMapping(&map, GL_RGB, GL_HALF_FLOAT, GL_RGB16F);
- InsertFormatMapping(&map, GL_RGB, GL_HALF_FLOAT_OES, GL_RGB16F);
-
- InsertFormatMapping(&map, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, GL_RGB8UI);
- InsertFormatMapping(&map, GL_RGB_INTEGER, GL_BYTE, GL_RGB8I);
- InsertFormatMapping(&map, GL_RGB_INTEGER, GL_UNSIGNED_SHORT, GL_RGB16UI);
- InsertFormatMapping(&map, GL_RGB_INTEGER, GL_SHORT, GL_RGB16I);
- InsertFormatMapping(&map, GL_RGB_INTEGER, GL_UNSIGNED_INT, GL_RGB32UI);
- InsertFormatMapping(&map, GL_RGB_INTEGER, GL_INT, GL_RGB32I);
-
- InsertFormatMapping(&map, GL_RG, GL_UNSIGNED_BYTE, GL_RG8);
- InsertFormatMapping(&map, GL_RG, GL_BYTE, GL_RG8_SNORM);
- InsertFormatMapping(&map, GL_RG, GL_FLOAT, GL_RG32F);
- InsertFormatMapping(&map, GL_RG, GL_HALF_FLOAT, GL_RG16F);
- InsertFormatMapping(&map, GL_RG, GL_HALF_FLOAT_OES, GL_RG16F);
-
- InsertFormatMapping(&map, GL_RG_INTEGER, GL_UNSIGNED_BYTE, GL_RG8UI);
- InsertFormatMapping(&map, GL_RG_INTEGER, GL_BYTE, GL_RG8I);
- InsertFormatMapping(&map, GL_RG_INTEGER, GL_UNSIGNED_SHORT, GL_RG16UI);
- InsertFormatMapping(&map, GL_RG_INTEGER, GL_SHORT, GL_RG16I);
- InsertFormatMapping(&map, GL_RG_INTEGER, GL_UNSIGNED_INT, GL_RG32UI);
- InsertFormatMapping(&map, GL_RG_INTEGER, GL_INT, GL_RG32I);
-
- InsertFormatMapping(&map, GL_RED, GL_UNSIGNED_BYTE, GL_R8);
- InsertFormatMapping(&map, GL_RED, GL_BYTE, GL_R8_SNORM);
- InsertFormatMapping(&map, GL_RED, GL_FLOAT, GL_R32F);
- InsertFormatMapping(&map, GL_RED, GL_HALF_FLOAT, GL_R16F);
- InsertFormatMapping(&map, GL_RED, GL_HALF_FLOAT_OES, GL_R16F);
-
- InsertFormatMapping(&map, GL_RED_INTEGER, GL_UNSIGNED_BYTE, GL_R8UI);
- InsertFormatMapping(&map, GL_RED_INTEGER, GL_BYTE, GL_R8I);
- InsertFormatMapping(&map, GL_RED_INTEGER, GL_UNSIGNED_SHORT, GL_R16UI);
- InsertFormatMapping(&map, GL_RED_INTEGER, GL_SHORT, GL_R16I);
- InsertFormatMapping(&map, GL_RED_INTEGER, GL_UNSIGNED_INT, GL_R32UI);
- InsertFormatMapping(&map, GL_RED_INTEGER, GL_INT, GL_R32I);
-
- InsertFormatMapping(&map, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, GL_LUMINANCE8_ALPHA8_EXT);
- InsertFormatMapping(&map, GL_LUMINANCE, GL_UNSIGNED_BYTE, GL_LUMINANCE8_EXT);
- InsertFormatMapping(&map, GL_ALPHA, GL_UNSIGNED_BYTE, GL_ALPHA8_EXT);
- InsertFormatMapping(&map, GL_LUMINANCE_ALPHA, GL_FLOAT, GL_LUMINANCE_ALPHA32F_EXT);
- InsertFormatMapping(&map, GL_LUMINANCE, GL_FLOAT, GL_LUMINANCE32F_EXT);
- InsertFormatMapping(&map, GL_ALPHA, GL_FLOAT, GL_ALPHA32F_EXT);
- InsertFormatMapping(&map, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT, GL_LUMINANCE_ALPHA16F_EXT);
- InsertFormatMapping(&map, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES, GL_LUMINANCE_ALPHA16F_EXT);
- InsertFormatMapping(&map, GL_LUMINANCE, GL_HALF_FLOAT, GL_LUMINANCE16F_EXT);
- InsertFormatMapping(&map, GL_LUMINANCE, GL_HALF_FLOAT_OES, GL_LUMINANCE16F_EXT);
- InsertFormatMapping(&map, GL_ALPHA, GL_HALF_FLOAT, GL_ALPHA16F_EXT);
- InsertFormatMapping(&map, GL_ALPHA, GL_HALF_FLOAT_OES, GL_ALPHA16F_EXT);
-
- InsertFormatMapping(&map, GL_BGRA_EXT, GL_UNSIGNED_BYTE, GL_BGRA8_EXT);
- InsertFormatMapping(&map, GL_BGRA_EXT, GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT, GL_BGRA4_ANGLE);
- InsertFormatMapping(&map, GL_BGRA_EXT, GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT, GL_BGR5_A1_ANGLE);
-
- InsertFormatMapping(&map, GL_SRGB_EXT, GL_UNSIGNED_BYTE, GL_SRGB8);
- InsertFormatMapping(&map, GL_SRGB_ALPHA_EXT, GL_UNSIGNED_BYTE, GL_SRGB8_ALPHA8);
-
- InsertFormatMapping(&map, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, GL_DEPTH_COMPONENT16);
- InsertFormatMapping(&map, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_DEPTH_COMPONENT32_OES);
- InsertFormatMapping(&map, GL_DEPTH_COMPONENT, GL_FLOAT, GL_DEPTH_COMPONENT32F);
-
- InsertFormatMapping(&map, GL_STENCIL, GL_UNSIGNED_BYTE, GL_STENCIL_INDEX8);
-
- InsertFormatMapping(&map, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH24_STENCIL8);
- InsertFormatMapping(&map, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GL_DEPTH32F_STENCIL8);
-
- return map;
- }
-
- GLint GetSizedInternalFormat(GLint internalformat, GLenum type)
- {
- switch(internalformat)
- {
- case GL_ALPHA:
- case GL_LUMINANCE:
- case GL_LUMINANCE_ALPHA:
- case GL_RED:
- case GL_RG:
- case GL_RGB:
- case GL_RGBA:
- case GL_RED_INTEGER:
- case GL_RG_INTEGER:
- case GL_RGB_INTEGER:
- case GL_RGBA_INTEGER:
- case GL_BGRA_EXT:
- case GL_DEPTH_COMPONENT:
- case GL_DEPTH_STENCIL:
- case GL_SRGB_EXT:
- case GL_SRGB_ALPHA_EXT:
- {
- static const FormatMap formatMap = BuildFormatMap();
- FormatMap::const_iterator iter = formatMap.find(FormatTypePair(internalformat, type));
- return (iter != formatMap.end()) ? iter->second : GL_NONE;
- }
- default:
- return internalformat;
- }
- }
unsigned int UniformComponentCount(GLenum type)
{
return -1;
}
- bool IsCompressed(GLenum format, GLint clientVersion)
+ bool IsCompressed(GLint internalformat, GLint clientVersion)
{
- switch(format)
+ switch(internalformat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
}
}
+ bool IsSizedInternalFormat(GLint internalformat)
+ {
+ switch(internalformat)
+ {
+ case GL_ALPHA8_EXT:
+ case GL_LUMINANCE8_ALPHA8_EXT:
+ case GL_LUMINANCE8_EXT:
+ case GL_R8:
+ case GL_R8UI:
+ case GL_R8I:
+ case GL_R16UI:
+ case GL_R16I:
+ case GL_R32UI:
+ case GL_R32I:
+ case GL_RG8:
+ case GL_RG8UI:
+ case GL_RG8I:
+ case GL_RG16UI:
+ case GL_RG16I:
+ case GL_RG32UI:
+ case GL_RG32I:
+ case GL_SRGB8_ALPHA8:
+ case GL_RGB8UI:
+ case GL_RGB8I:
+ case GL_RGB16UI:
+ case GL_RGB16I:
+ case GL_RGB32UI:
+ case GL_RGB32I:
+ case GL_RG8_SNORM:
+ case GL_R8_SNORM:
+ case GL_RGB10_A2:
+ case GL_RGBA8UI:
+ case GL_RGBA8I:
+ case GL_RGB10_A2UI:
+ case GL_RGBA16UI:
+ case GL_RGBA16I:
+ case GL_RGBA32I:
+ case GL_RGBA32UI:
+ case GL_RGBA4:
+ case GL_RGB5_A1:
+ case GL_RGB565:
+ case GL_RGB8:
+ case GL_RGBA8:
+ case GL_BGRA8_EXT: // GL_APPLE_texture_format_BGRA8888
+ case GL_R16F:
+ case GL_RG16F:
+ case GL_R11F_G11F_B10F:
+ case GL_RGB16F:
+ case GL_RGBA16F:
+ case GL_R32F:
+ case GL_RG32F:
+ case GL_RGB32F:
+ case GL_RGBA32F:
+ case GL_DEPTH_COMPONENT24:
+ case GL_DEPTH_COMPONENT32_OES:
+ case GL_DEPTH_COMPONENT32F:
+ case GL_DEPTH32F_STENCIL8:
+ case GL_DEPTH_COMPONENT16:
+ case GL_STENCIL_INDEX8:
+ case GL_DEPTH24_STENCIL8_OES:
+ case GL_RGBA8_SNORM:
+ case GL_SRGB8:
+ case GL_RGB8_SNORM:
+ case GL_RGB9_E5:
+ return true;
+ default:
+ return false;
+ }
+ }
+
GLenum ValidateSubImageParams(bool compressed, bool copy, GLenum target, GLint level, GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height, GLenum format, GLenum type, Texture *texture, GLint clientVersion)
{
}
else if(!copy) // CopyTexSubImage doesn't have format/type parameters.
{
- GLenum validationError = ValidateTextureFormatType(format, type, sizedInternalFormat, clientVersion);
+ GLenum validationError = ValidateTextureFormatType(format, type, sizedInternalFormat, target, clientVersion);
if(validationError != GL_NONE)
{
return validationError;
{
GLenum sizedInternalFormat = texture->getFormat(target, level);
- GLenum validationError = ValidateTextureFormatType(format, type, sizedInternalFormat, clientVersion);
+ GLenum validationError = ValidateTextureFormatType(format, type, sizedInternalFormat, target, clientVersion);
if(validationError != GL_NONE)
{
return validationError;
bool ValidateCopyFormats(GLenum textureFormat, GLenum colorbufferFormat)
{
- GLenum baseTexureFormat = GetBaseInternalFormat(textureFormat);
- GLenum baseColorbufferFormat = GetBaseInternalFormat(colorbufferFormat);
+ ASSERT(!gl::IsUnsizedInternalFormat(textureFormat));
+ ASSERT(!gl::IsUnsizedInternalFormat(colorbufferFormat));
+
+ if(GetColorComponentType(textureFormat) == GL_NONE)
+ {
+ return error(GL_INVALID_ENUM, false);
+ }
+
+ if(GetColorComponentType(colorbufferFormat) != GetColorComponentType(textureFormat))
+ {
+ return error(GL_INVALID_OPERATION, false);
+ }
+
+ if(GetColorEncoding(colorbufferFormat) != GetColorEncoding(textureFormat))
+ {
+ return error(GL_INVALID_OPERATION, false);
+ }
+
+ GLenum baseTexureFormat = gl::GetBaseInternalFormat(textureFormat);
+ GLenum baseColorbufferFormat = gl::GetBaseInternalFormat(colorbufferFormat);
// [OpenGL ES 2.0.24] table 3.9
// [OpenGL ES 3.0.5] table 3.16
return target == GL_TEXTURE_2D || IsCubemapTextureTarget(target) || target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY || target == GL_TEXTURE_RECTANGLE_ARB;
}
- GLenum ValidateTextureFormatType(GLenum format, GLenum type, GLint internalformat, GLint clientVersion)
+ GLenum ValidateTextureFormatType(GLenum format, GLenum type, GLint internalformat, GLenum target, GLint clientVersion)
{
switch(type)
{
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
case GL_BGRA_EXT: // GL_EXT_texture_format_BGRA8888
- case GL_DEPTH_STENCIL: // GL_OES_packed_depth_stencil (GL_DEPTH_STENCIL_OES)
- case GL_DEPTH_COMPONENT: // GL_OES_depth_texture
case GL_RED_EXT: // GL_EXT_texture_rg
case GL_RG_EXT: // GL_EXT_texture_rg
break;
+ case GL_DEPTH_STENCIL: // GL_OES_packed_depth_stencil (GL_DEPTH_STENCIL_OES)
+ case GL_DEPTH_COMPONENT: // GL_OES_depth_texture
+ switch(target)
+ {
+ case GL_TEXTURE_2D:
+ case GL_TEXTURE_2D_ARRAY:
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_X: // GL_OES_depth_texture_cube_map
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+ break;
+ default:
+ return GL_INVALID_OPERATION;
+ }
+ break;
case GL_RED_INTEGER:
case GL_RG_INTEGER:
case GL_RGB_INTEGER:
if((GLenum)internalformat != format)
{
- switch(internalformat)
+ if(gl::IsUnsizedInternalFormat(internalformat))
{
- // Unsized internal formats:
- case GL_ALPHA:
- case GL_RGB:
- case GL_RGBA:
- case GL_LUMINANCE:
- case GL_LUMINANCE_ALPHA:
- case GL_BGRA_EXT: // GL_EXT_texture_format_BGRA8888
- case GL_DEPTH_STENCIL: // GL_OES_packed_depth_stencil (GL_DEPTH_STENCIL_OES)
- case GL_DEPTH_COMPONENT: // GL_OES_depth_texture
- case GL_RED: // = GL_RED_EXT in GL_EXT_texture_rg
- case GL_RG: // = GL_RG_EXT in GL_EXT_texture_rg
- break;
- case GL_RED_INTEGER:
- case GL_RG_INTEGER:
- case GL_RGB_INTEGER:
- case GL_RGBA_INTEGER:
- if(clientVersion < 3)
- {
- return GL_INVALID_ENUM;
- }
- break;
- // Sized internal formats:
- case GL_ALPHA8_EXT:
- case GL_LUMINANCE8_ALPHA8_EXT:
- case GL_LUMINANCE8_EXT:
- case GL_R8:
- case GL_R8UI:
- case GL_R8I:
- case GL_R16UI:
- case GL_R16I:
- case GL_R32UI:
- case GL_R32I:
- case GL_RG8:
- case GL_RG8UI:
- case GL_RG8I:
- case GL_RG16UI:
- case GL_RG16I:
- case GL_RG32UI:
- case GL_RG32I:
- case GL_SRGB8_ALPHA8:
- case GL_RGB8UI:
- case GL_RGB8I:
- case GL_RGB16UI:
- case GL_RGB16I:
- case GL_RGB32UI:
- case GL_RGB32I:
- case GL_RG8_SNORM:
- case GL_R8_SNORM:
- case GL_RGB10_A2:
- case GL_RGBA8UI:
- case GL_RGBA8I:
- case GL_RGB10_A2UI:
- case GL_RGBA16UI:
- case GL_RGBA16I:
- case GL_RGBA32I:
- case GL_RGBA32UI:
- case GL_RGBA4:
- case GL_RGB5_A1:
- case GL_RGB565:
- case GL_RGB8:
- case GL_RGBA8:
- case GL_BGRA8_EXT: // GL_APPLE_texture_format_BGRA8888
- case GL_R16F:
- case GL_RG16F:
- case GL_R11F_G11F_B10F:
- case GL_RGB16F:
- case GL_RGBA16F:
- case GL_R32F:
- case GL_RG32F:
- case GL_RGB32F:
- case GL_RGBA32F:
- case GL_DEPTH_COMPONENT24:
- case GL_DEPTH_COMPONENT32_OES:
- case GL_DEPTH_COMPONENT32F:
- case GL_DEPTH32F_STENCIL8:
- case GL_DEPTH_COMPONENT16:
- case GL_STENCIL_INDEX8:
- case GL_DEPTH24_STENCIL8_OES:
- case GL_RGBA8_SNORM:
- case GL_SRGB8:
- case GL_RGB8_SNORM:
- case GL_RGB9_E5:
- break;
- default:
- return GL_INVALID_ENUM;
+ return GL_INVALID_OPERATION;
+ }
+
+ if(!IsSizedInternalFormat(internalformat))
+ {
+ return GL_INVALID_VALUE;
}
}
return 1;
}
- GLenum GetBaseInternalFormat(GLint internalformat)
- {
- switch(internalformat)
- {
- // Unsized internal formats which are valid as the <internalformat> parameter of CopyTexImage.
- case GL_RGB:
- case GL_RGBA:
- case GL_ALPHA:
- case GL_LUMINANCE:
- case GL_LUMINANCE_ALPHA:
- case GL_RED_EXT: // GL_EXT_texture_rg
- case GL_RG_EXT: // GL_EXT_texture_rg
- return internalformat;
-
- // [OpenGL ES 3.0 Table 3.13]
- case GL_R8: return GL_RED;
- case GL_R8_SNORM: return GL_RED;
- case GL_RG8: return GL_RG;
- case GL_RG8_SNORM: return GL_RG;
- case GL_RGB8: return GL_RGB;
- case GL_RGB8_SNORM: return GL_RGB;
- case GL_RGB565: return GL_RGB;
- case GL_RGBA4: return GL_RGBA;
- case GL_RGB5_A1: return GL_RGBA;
- case GL_RGBA8: return GL_RGBA;
- case GL_RGBA8_SNORM: return GL_RGBA;
- case GL_RGB10_A2: return GL_RGBA;
- case GL_RGB10_A2UI: return GL_RGBA;
- case GL_SRGB8: return GL_RGB;
- case GL_SRGB8_ALPHA8: return GL_RGBA;
- case GL_R16F: return GL_RED;
- case GL_RG16F: return GL_RG;
- case GL_RGB16F: return GL_RGB;
- case GL_RGBA16F: return GL_RGBA;
- case GL_R32F: return GL_RED;
- case GL_RG32F: return GL_RG;
- case GL_RGB32F: return GL_RGB;
- case GL_RGBA32F: return GL_RGBA;
- case GL_R11F_G11F_B10F: return GL_RGB;
- case GL_RGB9_E5: return GL_RGB;
- case GL_R8I: return GL_RED;
- case GL_R8UI: return GL_RED;
- case GL_R16I: return GL_RED;
- case GL_R16UI: return GL_RED;
- case GL_R32I: return GL_RED;
- case GL_R32UI: return GL_RED;
- case GL_RG8I: return GL_RG;
- case GL_RG8UI: return GL_RG;
- case GL_RG16I: return GL_RG;
- case GL_RG16UI: return GL_RG;
- case GL_RG32I: return GL_RG;
- case GL_RG32UI: return GL_RG;
- case GL_RGB8I: return GL_RGB;
- case GL_RGB8UI: return GL_RGB;
- case GL_RGB16I: return GL_RGB;
- case GL_RGB16UI: return GL_RGB;
- case GL_RGB32I: return GL_RGB;
- case GL_RGB32UI: return GL_RGB;
- case GL_RGBA8I: return GL_RGBA;
- case GL_RGBA8UI: return GL_RGBA;
- case GL_RGBA16I: return GL_RGBA;
- case GL_RGBA16UI: return GL_RGBA;
- case GL_RGBA32I: return GL_RGBA;
- case GL_RGBA32UI: return GL_RGBA;
-
- // GL_EXT_texture_storage
- case GL_ALPHA8_EXT: return GL_ALPHA;
- case GL_LUMINANCE8_ALPHA8_EXT: return GL_LUMINANCE_ALPHA;
- case GL_LUMINANCE8_EXT: return GL_LUMINANCE;
-
- case GL_BGRA8_EXT: return GL_BGRA_EXT; // GL_APPLE_texture_format_BGRA8888
-
- case GL_DEPTH_COMPONENT24: return GL_DEPTH_COMPONENT;
- case GL_DEPTH_COMPONENT32_OES: return GL_DEPTH_COMPONENT;
- case GL_DEPTH_COMPONENT32F: return GL_DEPTH_COMPONENT;
- case GL_DEPTH_COMPONENT16: return GL_DEPTH_COMPONENT;
- case GL_DEPTH32F_STENCIL8: return GL_DEPTH_STENCIL;
- case GL_DEPTH24_STENCIL8: return GL_DEPTH_STENCIL;
- case GL_STENCIL_INDEX8: return GL_STENCIL_INDEX_OES;
- default:
- UNREACHABLE(internalformat);
- break;
- }
-
- return GL_NONE;
- }
-
bool IsColorRenderable(GLint internalformat, GLint clientVersion)
{
if(IsCompressed(internalformat, clientVersion))
return true;
}
-
- sw::Format ConvertRenderbufferFormat(GLenum format)
- {
- switch(format)
- {
- case GL_NONE: return sw::FORMAT_NULL;
- case GL_RGBA4:
- case GL_RGB5_A1:
- case GL_RGBA8: return sw::FORMAT_A8B8G8R8;
- case GL_RGB565: return sw::FORMAT_R5G6B5;
- case GL_RGB8: return sw::FORMAT_X8B8G8R8;
- case GL_DEPTH_COMPONENT16:
- case GL_DEPTH_COMPONENT24:
- case GL_STENCIL_INDEX8:
- case GL_DEPTH24_STENCIL8_OES: return sw::FORMAT_D24S8;
- case GL_DEPTH_COMPONENT32_OES:return sw::FORMAT_D32;
- case GL_R8: return sw::FORMAT_R8;
- case GL_RG8: return sw::FORMAT_G8R8;
- case GL_R8I: return sw::FORMAT_R8I;
- case GL_RG8I: return sw::FORMAT_G8R8I;
- case GL_RGB8I: return sw::FORMAT_X8B8G8R8I;
- case GL_RGBA8I: return sw::FORMAT_A8B8G8R8I;
- case GL_R8UI: return sw::FORMAT_R8UI;
- case GL_RG8UI: return sw::FORMAT_G8R8UI;
- case GL_RGB8UI: return sw::FORMAT_X8B8G8R8UI;
- case GL_RGBA8UI: return sw::FORMAT_A8B8G8R8UI;
- case GL_R16I: return sw::FORMAT_R16I;
- case GL_RG16I: return sw::FORMAT_G16R16I;
- case GL_RGB16I: return sw::FORMAT_X16B16G16R16I;
- case GL_RGBA16I: return sw::FORMAT_A16B16G16R16I;
- case GL_R16UI: return sw::FORMAT_R16UI;
- case GL_RG16UI: return sw::FORMAT_G16R16UI;
- case GL_RGB16UI: return sw::FORMAT_X16B16G16R16UI;
- case GL_RGBA16UI: return sw::FORMAT_A16B16G16R16UI;
- case GL_R32I: return sw::FORMAT_R32I;
- case GL_RG32I: return sw::FORMAT_G32R32I;
- case GL_RGB32I: return sw::FORMAT_X32B32G32R32I;
- case GL_RGBA32I: return sw::FORMAT_A32B32G32R32I;
- case GL_R32UI: return sw::FORMAT_R32UI;
- case GL_RG32UI: return sw::FORMAT_G32R32UI;
- case GL_RGB32UI: return sw::FORMAT_X32B32G32R32UI;
- case GL_RGBA32UI: return sw::FORMAT_A32B32G32R32UI;
- case GL_R16F: return sw::FORMAT_R16F;
- case GL_RG16F: return sw::FORMAT_G16R16F;
- case GL_R11F_G11F_B10F: return sw::FORMAT_X16B16G16R16F_UNSIGNED;
- case GL_RGB16F: return sw::FORMAT_X16B16G16R16F;
- case GL_RGBA16F: return sw::FORMAT_A16B16G16R16F;
- case GL_R32F: return sw::FORMAT_R32F;
- case GL_RG32F: return sw::FORMAT_G32R32F;
- case GL_RGB32F: return sw::FORMAT_B32G32R32F;
- case GL_RGBA32F: return sw::FORMAT_A32B32G32R32F;
- case GL_RGB10_A2: return sw::FORMAT_A2B10G10R10;
- case GL_RGB10_A2UI: return sw::FORMAT_A2B10G10R10UI;
- case GL_SRGB8: return sw::FORMAT_SRGB8_X8;
- case GL_SRGB8_ALPHA8: return sw::FORMAT_SRGB8_A8;
- default: UNREACHABLE(format); return sw::FORMAT_NULL;
- }
- }
}
namespace sw2es
int AllocateFirstFreeBits(unsigned int *bits, unsigned int allocationSize, unsigned int bitsSize);
- bool IsCompressed(GLenum format, GLint clientVersion);
- GLint GetSizedInternalFormat(GLint internalFormat, GLenum type);
+ bool IsCompressed(GLint intenalformat, GLint clientVersion);
+ bool IsSizedInternalFormat(GLint internalformat); // Not compressed.
GLenum ValidateSubImageParams(bool compressed, bool copy, GLenum target, GLint level, GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height, GLenum format, GLenum type, Texture *texture, GLint clientVersion);
GLenum ValidateSubImageParams(bool compressed, bool copy, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
bool IsCubemapTextureTarget(GLenum target);
int CubeFaceIndex(GLenum cubeTarget);
bool IsTextureTarget(GLenum target);
- GLenum ValidateTextureFormatType(GLenum format, GLenum type, GLint internalformat, GLint clientVersion);
+ GLenum ValidateTextureFormatType(GLenum format, GLenum type, GLint internalformat, GLenum target, GLint clientVersion);
GLsizei GetTypeSize(GLenum type);
- GLenum GetBaseInternalFormat(GLint internalformat);
bool IsColorRenderable(GLint internalformat, GLint clientVersion);
bool IsDepthRenderable(GLint internalformat, GLint clientVersion);
sw::MipmapType ConvertMipMapFilter(GLenum minFilter);
sw::FilterType ConvertTextureFilter(GLenum minFilter, GLenum magFilter, float maxAnisotropy);
bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount, GLenum elementType, sw::DrawType &swPrimitiveType, int &primitiveCount, int &verticesPerPrimitive);
- sw::Format ConvertRenderbufferFormat(GLenum format);
}
namespace sw2es
case FORMAT_X8R8G8B8:
if(writeRGBA)
{
- Short4 c0 = RoundShort4(c.zyxw) | Short4(0x0000, 0x0000, 0x0000, 0xFFFFu);
+ Short4 c0 = RoundShort4(c.zyxw) | Short4(0x0000, 0x0000, 0x0000, 0x00FF);
*Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0));
}
else
case FORMAT_SRGB8_X8:
if(writeRGBA)
{
- Short4 c0 = RoundShort4(c) | Short4(0x0000, 0x0000, 0x0000, 0xFFFFu);
+ Short4 c0 = RoundShort4(c) | Short4(0x0000, 0x0000, 0x0000, 0x00FF);
*Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0));
}
else