Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-04-03 04:52:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1080137 - WebGL2: misc fixes to make new tex formats and sized internalformats actually work - r=jgilbert

Browse Source
This commit is contained in:
Benoit Jacob 2014-10-09 16:07:07 -04:00
parent 078386f131
commit 58b03977ff
11 changed files with 180 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
dom/canvas/WebGL2Context.cpp
View File

@ -65,10 +65,13 @@ WebGLContext::InitWebGL2()
const WebGLExtensionID sExtensionNativelySupportedArr[] = {
WebGLExtensionID::ANGLE_instanced_arrays,
WebGLExtensionID::EXT_blend_minmax,
WebGLExtensionID::EXT_sRGB,
WebGLExtensionID::OES_element_index_uint,
WebGLExtensionID::OES_standard_derivatives,
WebGLExtensionID::OES_texture_float,
WebGLExtensionID::OES_texture_float_linear,
WebGLExtensionID::OES_texture_half_float,
WebGLExtensionID::OES_texture_half_float_linear,
WebGLExtensionID::OES_vertex_array_object,
WebGLExtensionID::WEBGL_depth_texture,
WebGLExtensionID::WEBGL_draw_buffers

4
dom/canvas/WebGLContext.h
View File

@ -1081,8 +1081,6 @@ protected:
// -------------------------------------------------------------------------
// Validation functions (implemented in WebGLContextValidate.cpp)
TexInternalFormat BaseTexFormat(TexInternalFormat internalFormat) const;
bool CreateOffscreenGL(bool forceEnabled);
bool InitAndValidateGL();
bool ResizeBackbuffer(uint32_t width, uint32_t height);
@ -1165,7 +1163,7 @@ protected:
void TexParameter_base(GLenum target, GLenum pname,
GLint *intParamPtr, GLfloat *floatParamPtr);
void ConvertImage(size_t width, size_t height, size_t srcStride, size_t dstStride,
bool ConvertImage(size_t width, size_t height, size_t srcStride, size_t dstStride,
const uint8_t* src, uint8_t *dst,
WebGLTexelFormat srcFormat, bool srcPremultiplied,
WebGLTexelFormat dstFormat, bool dstPremultiplied,

100
dom/canvas/WebGLContextGL.cpp
View File

@ -411,11 +411,11 @@ WebGLContext::CopyTexSubImage2D_base(TexImageTarget texImageTarget,
framebuffertype = LOCAL_GL_UNSIGNED_BYTE;
}
TexInternalFormat effectiveinternalformat =
TexInternalFormat effectiveInternalFormat =
EffectiveInternalFormatFromUnsizedInternalFormatAndType(internalformat, framebuffertype);
// this should never fail, validation happened earlier.
MOZ_ASSERT(effectiveinternalformat != LOCAL_GL_NONE);
MOZ_ASSERT(effectiveInternalFormat != LOCAL_GL_NONE);
// check if the memory size of this texture may change with this call
bool sizeMayChange = !sub;
@ -423,7 +423,7 @@ WebGLContext::CopyTexSubImage2D_base(TexImageTarget texImageTarget,
const WebGLTexture::ImageInfo& imageInfo = tex->ImageInfoAt(texImageTarget, level);
sizeMayChange = width != imageInfo.Width() ||
height != imageInfo.Height() ||
effectiveinternalformat != imageInfo.EffectiveInternalFormat();
effectiveInternalFormat != imageInfo.EffectiveInternalFormat();
}
if (sizeMayChange)
@ -441,7 +441,7 @@ WebGLContext::CopyTexSubImage2D_base(TexImageTarget texImageTarget,
// first, we initialize the texture as black
if (!sub) {
tex->SetImageInfo(texImageTarget, level, width, height,
effectiveinternalformat,
effectiveInternalFormat,
WebGLImageDataStatus::UninitializedImageData);
tex->DoDeferredImageInitialization(texImageTarget, level);
}
@ -479,7 +479,7 @@ WebGLContext::CopyTexSubImage2D_base(TexImageTarget texImageTarget,
if (!sub) {
tex->SetImageInfo(texImageTarget, level, width, height,
effectiveinternalformat,
effectiveInternalFormat,
WebGLImageDataStatus::InitializedImageData);
}
}
@ -1171,12 +1171,12 @@ WebGLContext::GetFramebufferAttachmentParameter(JSContext* cx,
switch (pname) {
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT:
if (IsExtensionEnabled(WebGLExtensionID::EXT_sRGB)) {
const TexInternalFormat effectiveinternalformat =
const TexInternalFormat effectiveInternalFormat =
fba.Texture()->ImageInfoBase().EffectiveInternalFormat();
TexInternalFormat unsizedinternalformat = LOCAL_GL_NONE;
TexType type = LOCAL_GL_NONE;
UnsizedInternalFormatAndTypeFromEffectiveInternalFormat(
effectiveinternalformat, &unsizedinternalformat, &type);
effectiveInternalFormat, &unsizedinternalformat, &type);
MOZ_ASSERT(unsizedinternalformat != LOCAL_GL_NONE);
const bool srgb = unsizedinternalformat == LOCAL_GL_SRGB ||
unsizedinternalformat == LOCAL_GL_SRGB_ALPHA;
@ -1217,9 +1217,9 @@ WebGLContext::GetFramebufferAttachmentParameter(JSContext* cx,
if (!fba.IsComplete())
return JS::NumberValue(uint32_t(LOCAL_GL_NONE));
TexInternalFormat effectiveinternalformat =
TexInternalFormat effectiveInternalFormat =
fba.Texture()->ImageInfoAt(fba.ImageTarget(), fba.MipLevel()).EffectiveInternalFormat();
TexType type = TypeFromInternalFormat(effectiveinternalformat);
TexType type = TypeFromInternalFormat(effectiveInternalFormat);
GLenum ret = LOCAL_GL_NONE;
switch (type.get()) {
case LOCAL_GL_UNSIGNED_BYTE:
@ -3667,7 +3667,7 @@ WebGLContext::TexImage2D_base(TexImageTarget texImageTarget, GLint level,
const bool isDepthTexture = format == LOCAL_GL_DEPTH_COMPONENT ||
format == LOCAL_GL_DEPTH_STENCIL;
if (isDepthTexture) {
if (isDepthTexture && !IsWebGL2()) {
if (data != nullptr || level != 0)
return ErrorInvalidOperation("texImage2D: "
"with format of DEPTH_COMPONENT or DEPTH_STENCIL, "
@ -3678,17 +3678,27 @@ WebGLContext::TexImage2D_base(TexImageTarget texImageTarget, GLint level,
if (!ValidateTexInputData(type, jsArrayType, func))
return;
TexInternalFormat effectiveinternalformat =
TexInternalFormat effectiveInternalFormat =
EffectiveInternalFormatFromInternalFormatAndType(internalformat, type);
if (effectiveinternalformat == LOCAL_GL_NONE) {
if (effectiveInternalFormat == LOCAL_GL_NONE) {
return ErrorInvalidOperation("texImage2D: bad combination of internalformat and type");
}
WebGLTexelFormat dstFormat = GetWebGLTexelFormat(effectiveinternalformat);
WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
uint32_t srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(actualSrcFormat);
size_t srcTexelSize = size_t(-1);
if (srcFormat == WebGLTexelFormat::Auto) {
// we need to find the exact sized format of the source data. Slightly abusing
// EffectiveInternalFormatFromInternalFormatAndType for that purpose. Really, an unsized source format
// is the same thing as an unsized internalformat.
TexInternalFormat effectiveSourceFormat =
EffectiveInternalFormatFromInternalFormatAndType(format, type);
MOZ_ASSERT(effectiveSourceFormat != LOCAL_GL_NONE); // should have validated format/type combo earlier
const size_t srcbitsPerTexel = GetBitsPerTexel(effectiveSourceFormat);
MOZ_ASSERT((srcbitsPerTexel % 8) == 0); // should not have compressed formats here.
srcTexelSize = srcbitsPerTexel / 8;
} else {
srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(srcFormat);
}
CheckedUint32 checked_neededByteLength =
GetImageSize(height, width, srcTexelSize, mPixelStoreUnpackAlignment);
@ -3722,10 +3732,13 @@ WebGLContext::TexImage2D_base(TexImageTarget texImageTarget, GLint level,
void* pixels = nullptr;
WebGLImageDataStatus imageInfoStatusIfSuccess = WebGLImageDataStatus::UninitializedImageData;
WebGLTexelFormat dstFormat = GetWebGLTexelFormat(effectiveInternalFormat);
WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
if (byteLength) {
size_t bitspertexel = GetBitsPerTexel(effectiveinternalformat);
MOZ_ASSERT((bitspertexel % 8) == 0); // should not have compressed formats here.
size_t dstTexelSize = bitspertexel / 8;
size_t bitsPerTexel = GetBitsPerTexel(effectiveInternalFormat);
MOZ_ASSERT((bitsPerTexel % 8) == 0); // should not have compressed formats here.
size_t dstTexelSize = bitsPerTexel / 8;
size_t srcStride = srcStrideOrZero ? srcStrideOrZero : checked_alignedRowSize.value();
size_t dstPlainRowSize = dstTexelSize * width;
size_t unpackAlignment = mPixelStoreUnpackAlignment;
@ -3743,10 +3756,13 @@ WebGLContext::TexImage2D_base(TexImageTarget texImageTarget, GLint level,
{
size_t convertedDataSize = height * dstStride;
convertedData = new uint8_t[convertedDataSize];
ConvertImage(width, height, srcStride, dstStride,
static_cast<uint8_t*>(data), convertedData,
actualSrcFormat, srcPremultiplied,
dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize);
if (!ConvertImage(width, height, srcStride, dstStride,
static_cast<uint8_t*>(data), convertedData,
actualSrcFormat, srcPremultiplied,
dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize))
{
return ErrorInvalidOperation("texImage2D: Unsupported texture format conversion");
}
pixels = reinterpret_cast<void*>(convertedData.get());
}
imageInfoStatusIfSuccess = WebGLImageDataStatus::InitializedImageData;
@ -3766,7 +3782,7 @@ WebGLContext::TexImage2D_base(TexImageTarget texImageTarget, GLint level,
MOZ_ASSERT(imageInfoStatusIfSuccess != WebGLImageDataStatus::NoImageData);
tex->SetImageInfo(texImageTarget, level, width, height,
effectiveinternalformat, imageInfoStatusIfSuccess);
effectiveInternalFormat, imageInfoStatusIfSuccess);
}
void
@ -3880,10 +3896,14 @@ WebGLContext::TexSubImage2D_base(TexImageTarget texImageTarget, GLint level,
return ErrorInvalidOperation("texSubImage2D: type differs from that of the existing image");
}
WebGLTexelFormat dstFormat = GetWebGLTexelFormat(existingEffectiveInternalFormat);
WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
uint32_t srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(actualSrcFormat);
size_t srcTexelSize = size_t(-1);
if (srcFormat == WebGLTexelFormat::Auto) {
const size_t bitsPerTexel = GetBitsPerTexel(existingEffectiveInternalFormat);
MOZ_ASSERT((bitsPerTexel % 8) == 0); // should not have compressed formats here.
srcTexelSize = bitsPerTexel / 8;
} else {
srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(srcFormat);
}
if (width == 0 || height == 0)
return; // ES 2.0 says it has no effect, we better return right now
@ -3918,6 +3938,9 @@ WebGLContext::TexSubImage2D_base(TexImageTarget texImageTarget, GLint level,
void* pixels = data;
nsAutoArrayPtr<uint8_t> convertedData;
WebGLTexelFormat dstFormat = GetWebGLTexelFormat(existingEffectiveInternalFormat);
WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
// no conversion, no flipping, so we avoid copying anything and just pass the source pointer
bool noConversion = (actualSrcFormat == dstFormat &&
srcPremultiplied == mPixelStorePremultiplyAlpha &&
@ -3927,10 +3950,13 @@ WebGLContext::TexSubImage2D_base(TexImageTarget texImageTarget, GLint level,
if (!noConversion) {
size_t convertedDataSize = height * dstStride;
convertedData = new uint8_t[convertedDataSize];
ConvertImage(width, height, srcStride, dstStride,
static_cast<const uint8_t*>(data), convertedData,
actualSrcFormat, srcPremultiplied,
dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize);
if (!ConvertImage(width, height, srcStride, dstStride,
static_cast<const uint8_t*>(data), convertedData,
actualSrcFormat, srcPremultiplied,
dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize))
{
return ErrorInvalidOperation("texSubImage2D: Unsupported texture format conversion");
}
pixels = reinterpret_cast<void*>(convertedData.get());
}
@ -4099,12 +4125,9 @@ BaseTypeAndSizeFromUniformType(GLenum uType, GLenum *baseType, GLint *unitSize)
WebGLTexelFormat
mozilla::GetWebGLTexelFormat(TexInternalFormat effectiveinternalformat)
mozilla::GetWebGLTexelFormat(TexInternalFormat effectiveInternalFormat)
{
switch (effectiveinternalformat.get()) {
case LOCAL_GL_DEPTH_COMPONENT16: return WebGLTexelFormat::D16;
case LOCAL_GL_DEPTH_COMPONENT24: return WebGLTexelFormat::D32;
case LOCAL_GL_DEPTH24_STENCIL8: return WebGLTexelFormat::D24S8;
switch (effectiveInternalFormat.get()) {
case LOCAL_GL_RGBA8: return WebGLTexelFormat::RGBA8;
case LOCAL_GL_SRGB8_ALPHA8: return WebGLTexelFormat::RGBA8;
case LOCAL_GL_RGB8: return WebGLTexelFormat::RGB8;
@ -4126,8 +4149,7 @@ mozilla::GetWebGLTexelFormat(TexInternalFormat effectiveinternalformat)
case LOCAL_GL_RGB5_A1: return WebGLTexelFormat::RGBA5551;
case LOCAL_GL_RGB565: return WebGLTexelFormat::RGB565;
default:
MOZ_CRASH("Unhandled format");
return WebGLTexelFormat::BadFormat;
return WebGLTexelFormat::FormatNotSupportingAnyConversion;
}
}

12
dom/canvas/WebGLContextUtils.cpp
View File

@ -257,6 +257,18 @@ DriverFormatsFromEffectiveInternalFormat(gl::GLContext* gl,
driverFormat = LOCAL_GL_RGBA;
}
// WebGL2's new formats are not legal values for internalformat,
// as using unsized internalformat is deprecated.
if (driverFormat == LOCAL_GL_RED ||
driverFormat == LOCAL_GL_RG ||
driverFormat == LOCAL_GL_RED_INTEGER ||
driverFormat == LOCAL_GL_RG_INTEGER ||
driverFormat == LOCAL_GL_RGB_INTEGER ||
driverFormat == LOCAL_GL_RGBA_INTEGER)
{
driverInternalFormat = effectiveinternalformat.get();
}
// Cases where desktop OpenGL requires a sized internalformat,
// as opposed to the unsized internalformat that had the same
// GLenum value as 'format', in order to get the precise

219
dom/canvas/WebGLContextValidate.cpp
View File

@ -249,93 +249,6 @@ WebGLProgram::UpdateInfo()
return true;
}
/**
* Return the simple base format for a given internal format.
*
* \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE,
* GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA), or GL_NONE if invalid enum.
*/
TexInternalFormat
WebGLContext::BaseTexFormat(TexInternalFormat internalFormat) const
{
if (internalFormat == LOCAL_GL_ALPHA ||
internalFormat == LOCAL_GL_LUMINANCE ||
internalFormat == LOCAL_GL_LUMINANCE_ALPHA ||
internalFormat == LOCAL_GL_RGB ||
internalFormat == LOCAL_GL_RGBA)
{
return internalFormat;
}
if (IsExtensionEnabled(WebGLExtensionID::EXT_sRGB)) {
if (internalFormat == LOCAL_GL_SRGB)
return LOCAL_GL_RGB;
if (internalFormat == LOCAL_GL_SRGB_ALPHA)
return LOCAL_GL_RGBA;
}
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_compressed_texture_atc)) {
if (internalFormat == LOCAL_GL_ATC_RGB)
return LOCAL_GL_RGB;
if (internalFormat == LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA ||
internalFormat == LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA)
{
return LOCAL_GL_RGBA;
}
}
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_compressed_texture_etc1)) {
if (internalFormat == LOCAL_GL_ETC1_RGB8_OES)
return LOCAL_GL_RGB;
}
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_compressed_texture_pvrtc)) {
if (internalFormat == LOCAL_GL_COMPRESSED_RGB_PVRTC_2BPPV1 ||
internalFormat == LOCAL_GL_COMPRESSED_RGB_PVRTC_4BPPV1)
{
return LOCAL_GL_RGB;
}
if (internalFormat == LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1 ||
internalFormat == LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1)
{
return LOCAL_GL_RGBA;
}
}
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_compressed_texture_s3tc)) {
if (internalFormat == LOCAL_GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
return LOCAL_GL_RGB;
if (internalFormat == LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
internalFormat == LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
internalFormat == LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
{
return LOCAL_GL_RGBA;
}
}
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_depth_texture)) {
if (internalFormat == LOCAL_GL_DEPTH_COMPONENT ||
internalFormat == LOCAL_GL_DEPTH_COMPONENT16 ||
internalFormat == LOCAL_GL_DEPTH_COMPONENT32)
{
return LOCAL_GL_DEPTH_COMPONENT;
}
if (internalFormat == LOCAL_GL_DEPTH_STENCIL ||
internalFormat == LOCAL_GL_DEPTH24_STENCIL8)
{
return LOCAL_GL_DEPTH_STENCIL;
}
}
MOZ_ASSERT(false, "Unhandled internalFormat");
return LOCAL_GL_NONE;
}
bool WebGLContext::ValidateBlendEquationEnum(GLenum mode, const char *info)
{
switch (mode) {
@ -572,6 +485,22 @@ WebGLContext::ValidateTexImageFormat(GLenum format, WebGLTexImageFunc func)
return true;
}
/* WebGL2 new formats */
if (format == LOCAL_GL_RED ||
format == LOCAL_GL_RG ||
format == LOCAL_GL_RED_INTEGER ||
format == LOCAL_GL_RG_INTEGER ||
format == LOCAL_GL_RGB_INTEGER ||
format == LOCAL_GL_RGBA_INTEGER)
{
bool valid = IsWebGL2();
if (!valid) {
ErrorInvalidEnum("%s: invalid format %s: requires WebGL version 2.0 or newer",
InfoFrom(func), EnumName(format));
}
return valid;
}
/* WEBGL_depth_texture added formats */
if (format == LOCAL_GL_DEPTH_COMPONENT ||
format == LOCAL_GL_DEPTH_STENCIL)
@ -583,8 +512,9 @@ WebGLContext::ValidateTexImageFormat(GLenum format, WebGLTexImageFunc func)
}
// If WEBGL_depth_texture is enabled, then it is not allowed to be used with the
// texSubImage, copyTexImage, or copyTexSubImage methods
if (func == WebGLTexImageFunc::TexSubImage ||
// copyTexImage, or copyTexSubImage methods, and it is not allowed with
// texSubImage in WebGL1.
if ((func == WebGLTexImageFunc::TexSubImage && !IsWebGL2()) ||
func == WebGLTexImageFunc::CopyTexImage ||
func == WebGLTexImageFunc::CopyTexSubImage)
{
@ -663,6 +593,23 @@ WebGLContext::ValidateTexImageType(GLenum type,
return true;
}
/* WebGL2 new types */
if (type == LOCAL_GL_BYTE ||
type == LOCAL_GL_SHORT ||
type == LOCAL_GL_INT ||
type == LOCAL_GL_FLOAT_32_UNSIGNED_INT_24_8_REV ||
type == LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV ||
type == LOCAL_GL_UNSIGNED_INT_10F_11F_11F_REV ||
type == LOCAL_GL_UNSIGNED_INT_5_9_9_9_REV)
{
bool validType = IsWebGL2();
if (!validType) {
ErrorInvalidEnum("%s: invalid type %s: requires WebGL version 2.0 or newer",
InfoFrom(func), WebGLContext::EnumName(type));
}
return validType;
}
/* OES_texture_float added types */
if (type == LOCAL_GL_FLOAT) {
bool validType = IsExtensionEnabled(WebGLExtensionID::OES_texture_float);
@ -1044,50 +991,12 @@ WebGLContext::ValidateTexImageFormatAndType(GLenum format,
return false;
}
bool validCombo = false;
switch (format) {
case LOCAL_GL_ALPHA:
case LOCAL_GL_LUMINANCE:
case LOCAL_GL_LUMINANCE_ALPHA:
validCombo = (type == LOCAL_GL_UNSIGNED_BYTE ||
type == LOCAL_GL_HALF_FLOAT ||
type == LOCAL_GL_FLOAT);
break;
case LOCAL_GL_RGB:
case LOCAL_GL_SRGB:
validCombo = (type == LOCAL_GL_UNSIGNED_BYTE ||
type == LOCAL_GL_UNSIGNED_SHORT_5_6_5 ||
type == LOCAL_GL_HALF_FLOAT ||
type == LOCAL_GL_FLOAT);
break;
case LOCAL_GL_RGBA:
case LOCAL_GL_SRGB_ALPHA:
validCombo = (type == LOCAL_GL_UNSIGNED_BYTE ||
type == LOCAL_GL_UNSIGNED_SHORT_4_4_4_4 ||
type == LOCAL_GL_UNSIGNED_SHORT_5_5_5_1 ||
type == LOCAL_GL_HALF_FLOAT ||
type == LOCAL_GL_FLOAT);
break;
case LOCAL_GL_DEPTH_COMPONENT:
validCombo = (type == LOCAL_GL_UNSIGNED_SHORT ||
type == LOCAL_GL_UNSIGNED_INT);
break;
case LOCAL_GL_DEPTH_STENCIL:
validCombo = (type == LOCAL_GL_UNSIGNED_INT_24_8);
break;
default:
// Only valid formats should be passed to the switch stmt.
MOZ_ASSERT(false, "Unexpected format and type combo. How'd this happen?");
validCombo = false;
// Fall through to return an InvalidOperations. This will alert us to the
// unexpected case that needs fixing in builds without asserts.
}
// Here we're reinterpreting format as an unsized internalformat;
// these are the same in practice and there's no point in having the
// same code implemented twice.
TexInternalFormat effective =
EffectiveInternalFormatFromInternalFormatAndType(format, type);
bool validCombo = effective != LOCAL_GL_NONE;
if (!validCombo)
ErrorInvalidOperation("%s: invalid combination of format %s and type %s",
@ -1198,6 +1107,10 @@ WebGLContext::ValidateTexInputData(GLenum type, int jsArrayType, WebGLTexImageFu
validInput = (jsArrayType == -1 || jsArrayType == js::Scalar::Uint8);
break;
case LOCAL_GL_BYTE:
validInput = (jsArrayType == -1 || jsArrayType == js::Scalar::Int8);
break;
case LOCAL_GL_HALF_FLOAT:
case LOCAL_GL_UNSIGNED_SHORT:
case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
@ -1206,11 +1119,22 @@ WebGLContext::ValidateTexInputData(GLenum type, int jsArrayType, WebGLTexImageFu
validInput = (jsArrayType == -1 || jsArrayType == js::Scalar::Uint16);
break;
case LOCAL_GL_SHORT:
validInput = (jsArrayType == -1 || jsArrayType == js::Scalar::Int16);
break;
case LOCAL_GL_UNSIGNED_INT:
case LOCAL_GL_UNSIGNED_INT_24_8:
case LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV:
case LOCAL_GL_UNSIGNED_INT_10F_11F_11F_REV:
case LOCAL_GL_UNSIGNED_INT_5_9_9_9_REV:
validInput = (jsArrayType == -1 || jsArrayType == js::Scalar::Uint32);
break;
case LOCAL_GL_INT:
validInput = (jsArrayType == -1 || jsArrayType == js::Scalar::Int32);
break;
case LOCAL_GL_FLOAT:
validInput = (jsArrayType == -1 || jsArrayType == js::Scalar::Float32);
break;
@ -1314,22 +1238,19 @@ WebGLContext::ValidateTexImage(GLuint dims, TexImageTarget texImageTarget,
return false;
}
} else if (format != internalFormat) {
/* WebGL and OpenGL ES 2.0 impose additional restrictions on the
* combinations of format, internalFormat, and type that can be
* used. Formats and types that require additional extensions
* (e.g., GL_FLOAT requires GL_OES_texture_float) are filtered
* elsewhere.
*/
ErrorInvalidOperation("%s: format does not match internalformat", info);
return false;
}
/* check internalFormat */
// TODO: Not sure if this is a bit of over kill.
if (BaseTexFormat(internalFormat) == LOCAL_GL_NONE) {
MOZ_ASSERT(false);
ErrorInvalidValue("%s:", info);
return false;
if (IsWebGL2()) {
// In WebGL2, it's OK to have internalformat != format if internalformat is the sized
// internal format corresponding to the (format, type) pair according to Table 3.2
// in the OpenGL ES 3.0.3 spec.
if (internalFormat != EffectiveInternalFormatFromInternalFormatAndType(format, type)) {
ErrorInvalidOperation("%s: internalformat does not match format and type", info);
return false;
}
} else {
// in WebGL 1, format must be equal to internalformat
ErrorInvalidOperation("%s: internalformat does not match format", info);
return false;
}
}
/* Check texture image size */

6
dom/canvas/WebGLInternalFormatsTable.h
View File

@ -21,7 +21,7 @@ WEBGL_INTERNAL_FORMAT(RGB8, RGB, UNSIGNED_BYTE)
WEBGL_INTERNAL_FORMAT(RGBA4, RGBA, UNSIGNED_SHORT_4_4_4_4)
WEBGL_INTERNAL_FORMAT(RGB5_A1, RGBA, UNSIGNED_SHORT_5_5_5_1)
WEBGL_INTERNAL_FORMAT(RGBA8, RGBA, UNSIGNED_BYTE)
WEBGL_INTERNAL_FORMAT(RGB10_A2, RGB, UNSIGNED_INT_2_10_10_10_REV)
WEBGL_INTERNAL_FORMAT(RGB10_A2, RGBA, UNSIGNED_INT_2_10_10_10_REV)
WEBGL_INTERNAL_FORMAT(DEPTH_COMPONENT16, DEPTH_COMPONENT, UNSIGNED_SHORT)
WEBGL_INTERNAL_FORMAT(DEPTH_COMPONENT24, DEPTH_COMPONENT, UNSIGNED_INT)
WEBGL_INTERNAL_FORMAT(R8, RED, UNSIGNED_BYTE)
@ -29,10 +29,10 @@ WEBGL_INTERNAL_FORMAT(RG8, RG, UNSIGNED_BYTE)
WEBGL_INTERNAL_FORMAT(R16F, RED, HALF_FLOAT)
WEBGL_INTERNAL_FORMAT(R32F, RED, FLOAT)
WEBGL_INTERNAL_FORMAT(RG16F, RG, HALF_FLOAT)
WEBGL_INTERNAL_FORMAT(RG32F, RG, UNSIGNED_BYTE)
WEBGL_INTERNAL_FORMAT(RG32F, RG, FLOAT)
WEBGL_INTERNAL_FORMAT(R8I, RED_INTEGER, BYTE)
WEBGL_INTERNAL_FORMAT(R8UI, RED_INTEGER, UNSIGNED_BYTE)
WEBGL_INTERNAL_FORMAT(R16I, RED_INTEGER, BYTE)
WEBGL_INTERNAL_FORMAT(R16I, RED_INTEGER, SHORT)
WEBGL_INTERNAL_FORMAT(R16UI, RED_INTEGER, UNSIGNED_SHORT)
WEBGL_INTERNAL_FORMAT(R32I, RED_INTEGER, INT)
WEBGL_INTERNAL_FORMAT(R32UI, RED_INTEGER, UNSIGNED_INT)

6
dom/canvas/WebGLStrongTypes.h
View File

@ -294,6 +294,7 @@ STRONG_GLENUM_END(TexFormat)
STRONG_GLENUM_BEGIN(TexInternalFormat)
STRONG_GLENUM_VALUE(NONE),
STRONG_GLENUM_VALUE(DEPTH_COMPONENT),
STRONG_GLENUM_VALUE(RED),
STRONG_GLENUM_VALUE(ALPHA),
STRONG_GLENUM_VALUE(RGB),
STRONG_GLENUM_VALUE(RGBA),
@ -309,6 +310,8 @@ STRONG_GLENUM_BEGIN(TexInternalFormat)
STRONG_GLENUM_VALUE(RGB10_A2),
STRONG_GLENUM_VALUE(DEPTH_COMPONENT16),
STRONG_GLENUM_VALUE(DEPTH_COMPONENT24),
STRONG_GLENUM_VALUE(RG),
STRONG_GLENUM_VALUE(RG_INTEGER),
STRONG_GLENUM_VALUE(R8),
STRONG_GLENUM_VALUE(RG8),
STRONG_GLENUM_VALUE(R16F),
@ -372,6 +375,9 @@ STRONG_GLENUM_BEGIN(TexInternalFormat)
STRONG_GLENUM_VALUE(RGB16I),
STRONG_GLENUM_VALUE(RGBA8I),
STRONG_GLENUM_VALUE(RGB8I),
STRONG_GLENUM_VALUE(RED_INTEGER),
STRONG_GLENUM_VALUE(RGB_INTEGER),
STRONG_GLENUM_VALUE(RGBA_INTEGER),
STRONG_GLENUM_VALUE(R8_SNORM),
STRONG_GLENUM_VALUE(RG8_SNORM),
STRONG_GLENUM_VALUE(RGB8_SNORM),

14
dom/canvas/WebGLTexelConversions.cpp
View File

@ -325,7 +325,7 @@ public:
} // end anonymous namespace
void
bool
WebGLContext::ConvertImage(size_t width, size_t height, size_t srcStride, size_t dstStride,
const uint8_t* src, uint8_t *dst,
WebGLTexelFormat srcFormat, bool srcPremultiplied,
@ -333,7 +333,7 @@ WebGLContext::ConvertImage(size_t width, size_t height, size_t srcStride, size_t
size_t dstTexelSize)
{
if (width <= 0 || height <= 0)
return;
return true;
const bool FormatsRequireNoPremultiplicationOp =
!HasAlpha(srcFormat) ||
@ -368,7 +368,13 @@ WebGLContext::ConvertImage(size_t width, size_t height, size_t srcStride, size_t
ptr += srcStride;
dst_row += dst_delta;
}
return;
return true;
}
if (srcFormat == WebGLTexelFormat::FormatNotSupportingAnyConversion ||
dstFormat == WebGLTexelFormat::FormatNotSupportingAnyConversion)
{
return false;
}
uint8_t* dstStart = dst;
@ -394,6 +400,8 @@ WebGLContext::ConvertImage(size_t width, size_t height, size_t srcStride, size_t
// and would be a bug in our code.
NS_RUNTIMEABORT("programming mistake in WebGL texture conversions");
}
return true;
}
} // end namespace mozilla

6
dom/canvas/WebGLTexelConversions.h
View File

@ -232,15 +232,12 @@ GLFormatForTexelFormat(WebGLTexelFormat format) {
case WebGLTexelFormat::RGBA5551: return LOCAL_GL_RGBA;
case WebGLTexelFormat::RGBA4444: return LOCAL_GL_RGBA;
case WebGLTexelFormat::RGB565: return LOCAL_GL_RGB;
case WebGLTexelFormat::D16: return LOCAL_GL_DEPTH_COMPONENT;
case WebGLTexelFormat::RGB8: return LOCAL_GL_RGB;
case WebGLTexelFormat::RGBA8: return LOCAL_GL_RGBA;
case WebGLTexelFormat::BGRA8: return LOCAL_GL_BGRA;
case WebGLTexelFormat::BGRX8: return LOCAL_GL_BGR;
case WebGLTexelFormat::R32F: return LOCAL_GL_LUMINANCE;
case WebGLTexelFormat::A32F: return LOCAL_GL_ALPHA;
case WebGLTexelFormat::D32: return LOCAL_GL_DEPTH_COMPONENT;
case WebGLTexelFormat::D24S8: return LOCAL_GL_DEPTH_STENCIL;
case WebGLTexelFormat::RA32F: return LOCAL_GL_LUMINANCE_ALPHA;
case WebGLTexelFormat::RGB32F: return LOCAL_GL_RGB;
case WebGLTexelFormat::RGBA32F: return LOCAL_GL_RGBA;
@ -266,7 +263,6 @@ inline size_t TexelBytesForFormat(WebGLTexelFormat format) {
case WebGLTexelFormat::RGB565:
case WebGLTexelFormat::R16F:
case WebGLTexelFormat::A16F:
case WebGLTexelFormat::D16:
return 2;
case WebGLTexelFormat::RGB8:
return 3;
@ -275,8 +271,6 @@ inline size_t TexelBytesForFormat(WebGLTexelFormat format) {
case WebGLTexelFormat::BGRX8:
case WebGLTexelFormat::R32F:
case WebGLTexelFormat::A32F:
case WebGLTexelFormat::D32:
case WebGLTexelFormat::D24S8:
case WebGLTexelFormat::RA16F:
return 4;
case WebGLTexelFormat::RGB16F:

15
dom/canvas/WebGLTexture.cpp
View File

@ -570,10 +570,17 @@ WebGLTexture::DoDeferredImageInitialization(TexImageTarget imageTarget, GLint le
&driverInternalFormat, &driverFormat, &driverType);
mContext->GetAndFlushUnderlyingGLErrors();
gl->fTexImage2D(imageTarget.get(), level, driverInternalFormat,
imageInfo.mWidth, imageInfo.mHeight,
0, driverFormat, driverType,
zeros);
if (mImmutable) {
gl->fTexSubImage2D(imageTarget.get(), level, 0, 0,
imageInfo.mWidth, imageInfo.mHeight,
driverFormat, driverType,
zeros);
} else {
gl->fTexImage2D(imageTarget.get(), level, driverInternalFormat,
imageInfo.mWidth, imageInfo.mHeight,
0, driverFormat, driverType,
zeros);
}
GLenum error = mContext->GetAndFlushUnderlyingGLErrors();
if (error) {
// Should only be OUT_OF_MEMORY. Anyway, there's no good way to recover from this here.

8
dom/canvas/WebGLTypes.h
View File

@ -98,9 +98,8 @@ MOZ_END_ENUM_CLASS(WebGLImageDataStatus)
MOZ_BEGIN_ENUM_CLASS(WebGLTexelFormat, int)
// returned by SurfaceFromElementResultToImageSurface to indicate absence of image data
None,
// dummy error code returned by GetWebGLTexelFormat in error cases,
// after assertion failure (so this never happens in debug builds)
BadFormat,
// common value for formats for which format conversions are not supported
FormatNotSupportingAnyConversion,
// dummy pseudo-format meaning "use the other format".
// For example, if SrcFormat=Auto and DstFormat=RGB8, then the source
// is implicitly treated as being RGB8 itself.
@ -108,8 +107,6 @@ MOZ_BEGIN_ENUM_CLASS(WebGLTexelFormat, int)
// 1-channel formats
R8,
A8,
D16, // WEBGL_depth_texture
D32, // WEBGL_depth_texture
R16F, // OES_texture_half_float
A16F, // OES_texture_half_float
R32F, // OES_texture_float
@ -118,7 +115,6 @@ MOZ_BEGIN_ENUM_CLASS(WebGLTexelFormat, int)
RA8,
RA16F, // OES_texture_half_float
RA32F, // OES_texture_float
D24S8, // WEBGL_depth_texture
// 3-channel formats
RGB8,
BGRX8, // used for DOM elements. Source format only.