bool WebGLTexture::IsComplete(uint32_t texUnit, const char** const out_reason) const { // Texture completeness is established at GLES 3.0.4, p160-161. // "[A] texture is complete unless any of the following conditions hold true:" // "* Any dimension of the `level_base` array is not positive." const ImageInfo& baseImageInfo = BaseImageInfo(); if (!baseImageInfo.IsDefined()) { // In case of undefined texture image, we don't print any message because this is // a very common and often legitimate case (asynchronous texture loading). *out_reason = nullptr; return false; } if (!baseImageInfo.mWidth || !baseImageInfo.mHeight || !baseImageInfo.mDepth) { *out_reason = "The dimensions of `level_base` are not all positive."; return false; } // "* The texture is a cube map texture, and is not cube complete." if (IsCubeMap() && !IsCubeComplete()) { *out_reason = "Cubemaps must be \"cube complete\"."; return false; } WebGLSampler* sampler = mContext->mBoundSamplers[texUnit]; TexMinFilter minFilter = sampler ? sampler->mMinFilter : mMinFilter; TexMagFilter magFilter = sampler ? sampler->mMagFilter : mMagFilter; // "* The minification filter requires a mipmap (is neither NEAREST nor LINEAR) and // the texture is not mipmap complete." const bool requiresMipmap = (minFilter != LOCAL_GL_NEAREST && minFilter != LOCAL_GL_LINEAR); if (requiresMipmap && !IsMipmapComplete(texUnit)) { *out_reason = "Because the minification filter requires mipmapping, the texture" " must be \"mipmap complete\"."; return false; } const bool isMinFilteringNearest = (minFilter == LOCAL_GL_NEAREST || minFilter == LOCAL_GL_NEAREST_MIPMAP_NEAREST); const bool isMagFilteringNearest = (magFilter == LOCAL_GL_NEAREST); const bool isFilteringNearestOnly = (isMinFilteringNearest && isMagFilteringNearest); if (!isFilteringNearestOnly) { auto formatUsage = baseImageInfo.mFormat; auto format = formatUsage->format; // "* The effective internal format specified for the texture arrays is a sized // internal color format that is not texture-filterable, and either the // magnification filter is not NEAREST or the minification filter is neither // NEAREST nor NEAREST_MIPMAP_NEAREST." // Since all (GLES3) unsized color formats are filterable just like their sized // equivalents, we don't have to care whether its sized or not. if (format->isColorFormat && !formatUsage->isFilterable) { *out_reason = "Because minification or magnification filtering is not NEAREST" " or NEAREST_MIPMAP_NEAREST, and the texture's format is a" " color format, its format must be \"texture-filterable\"."; return false; } // "* The effective internal format specified for the texture arrays is a sized // internal depth or depth and stencil format, the value of // TEXTURE_COMPARE_MODE is NONE[1], and either the magnification filter is not // NEAREST, or the minification filter is neither NEAREST nor // NEAREST_MIPMAP_NEAREST." // [1]: This sounds suspect, but is explicitly noted in the change log for GLES // 3.0.1: // "* Clarify that a texture is incomplete if it has a depth component, no // shadow comparison, and linear filtering (also Bug 9481)." // As of OES_packed_depth_stencil rev #3, the sample code explicitly samples from // a DEPTH_STENCIL_OES texture with a min-filter of LINEAR. Therefore we relax // this restriction if WEBGL_depth_texture is enabled. if (!mContext->IsExtensionEnabled(WebGLExtensionID::WEBGL_depth_texture)) { if (format->hasDepth && mTexCompareMode != LOCAL_GL_NONE) { *out_reason = "A depth or depth-stencil format with TEXTURE_COMPARE_MODE" " of NONE must have minification or magnification filtering" " of NEAREST or NEAREST_MIPMAP_NEAREST."; return false; } } } // Texture completeness is effectively (though not explicitly) amended for GLES2 by // the "Texture Access" section under $3.8 "Fragment Shaders". This also applies to // vertex shaders, as noted on GLES 2.0.25, p41. if (!mContext->IsWebGL2()) { // GLES 2.0.25, p87-88: // "Calling a sampler from a fragment shader will return (R,G,B,A)=(0,0,0,1) if // any of the following conditions are true:" // "* A two-dimensional sampler is called, the minification filter is one that // requires a mipmap[...], and the sampler's associated texture object is not // complete[.]" // (already covered) // "* A two-dimensional sampler is called, the minification filter is not one that // requires a mipmap (either NEAREST nor[sic] LINEAR), and either dimension of // the level zero array of the associated texture object is not positive." // (already covered) // "* A two-dimensional sampler is called, the corresponding texture image is a // non-power-of-two image[...], and either the texture wrap mode is not // CLAMP_TO_EDGE, or the minification filter is neither NEAREST nor LINEAR." // "* A cube map sampler is called, any of the corresponding texture images are // non-power-of-two images, and either the texture wrap mode is not // CLAMP_TO_EDGE, or the minification filter is neither NEAREST nor LINEAR." if (!baseImageInfo.IsPowerOfTwo()) { TexWrap wrapS = sampler ? sampler->mWrapS : mWrapS; TexWrap wrapT = sampler ? sampler->mWrapT : mWrapT; // "either the texture wrap mode is not CLAMP_TO_EDGE" if (wrapS != LOCAL_GL_CLAMP_TO_EDGE || wrapT != LOCAL_GL_CLAMP_TO_EDGE) { *out_reason = "Non-power-of-two textures must have a wrap mode of" " CLAMP_TO_EDGE."; return false; } // "or the minification filter is neither NEAREST nor LINEAR" if (requiresMipmap) { *out_reason = "Mipmapping requires power-of-two textures."; return false; } } // "* A cube map sampler is called, and either the corresponding cube map texture // image is not cube complete, or TEXTURE_MIN_FILTER is one that requires a // mipmap and the texture is not mipmap cube complete." // (already covered) } return true; }
WebGLTextureFakeBlackStatus WebGLTexture::ResolvedFakeBlackStatus() { if (MOZ_LIKELY(mFakeBlackStatus != WebGLTextureFakeBlackStatus::Unknown)) return mFakeBlackStatus; // Determine if the texture needs to be faked as a black texture. // See 3.8.2 Shader Execution in the OpenGL ES 2.0.24 spec, and 3.8.13 in // the OpenGL ES 3.0.4 spec. if (!IsMipmapRangeValid()) { mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; return mFakeBlackStatus; } for (size_t face = 0; face < mFacesCount; ++face) { WebGLImageDataStatus status = ImageInfoAtFace(face, EffectiveBaseMipmapLevel()).mImageDataStatus; if (status == WebGLImageDataStatus::NoImageData) { // In case of undefined texture image, we don't print any message // because this is a very common and often legitimate case // (asynchronous texture loading). mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; return mFakeBlackStatus; } } const char preamble[] = "A texture is going to be rendered as if it were" " black, as per the OpenGL ES 2.0.24 spec section" " 3.8.2, because it"; if (mTarget == LOCAL_GL_TEXTURE_2D || mTarget == LOCAL_GL_TEXTURE_3D) { int dim = mTarget == LOCAL_GL_TEXTURE_2D ? 2 : 3; if (DoesMinFilterRequireMipmap()) { if (!IsMipmapComplete()) { mContext->GenerateWarning("%s is a %dD texture, with a" " minification filter requiring a" " mipmap, and is not mipmap complete" " (as defined in section 3.7.10).", preamble, dim); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } else if (!mContext->IsWebGL2() && !ImageInfoBase().IsPowerOfTwo()) { mContext->GenerateWarning("%s is a %dD texture, with a" " minification filter requiring a" " mipmap, and either its width or" " height is not a power of two.", preamble, dim); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } } else { // No mipmap required here. if (!ImageInfoBase().IsPositive()) { mContext->GenerateWarning("%s is a %dD texture and its width or" " height is equal to zero.", preamble, dim); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } else if (!AreBothWrapModesClampToEdge() && !mContext->IsWebGL2() && !ImageInfoBase().IsPowerOfTwo()) { mContext->GenerateWarning("%s is a %dD texture, with a" " minification filter not requiring a" " mipmap, with its width or height" " not a power of two, and with a wrap" " mode different from CLAMP_TO_EDGE.", preamble, dim); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } } } else { // Cube map bool legalImageSize = true; if (!mContext->IsWebGL2()) { for (size_t face = 0; face < mFacesCount; ++face) legalImageSize &= ImageInfoAtFace(face, 0).IsPowerOfTwo(); } if (DoesMinFilterRequireMipmap()) { if (!IsMipmapCubeComplete()) { mContext->GenerateWarning("%s is a cube map texture, with a" " minification filter requiring a" " mipmap, and is not mipmap cube" " complete (as defined in section" " 3.7.10).", preamble); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } else if (!legalImageSize) { mContext->GenerateWarning("%s is a cube map texture, with a" " minification filter requiring a" " mipmap, and either the width or the" " height of some level 0 image is not" " a power of two.", preamble); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } } else // no mipmap required { if (!IsCubeComplete()) { mContext->GenerateWarning("%s is a cube map texture, with a" " minification filter not requiring a" " mipmap, and is not cube complete" " (as defined in section 3.7.10).", preamble); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } else if (!AreBothWrapModesClampToEdge() && !legalImageSize) { mContext->GenerateWarning("%s is a cube map texture, with a" " minification filter not requiring a" " mipmap, with some level 0 image" " having width or height not a power" " of two, and with a wrap mode" " different from CLAMP_TO_EDGE.", preamble); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } } } TexType type = TypeFromInternalFormat(ImageInfoBase().mEffectiveInternalFormat); const char* badFormatText = nullptr; const char* extText = nullptr; if (type == LOCAL_GL_FLOAT && !Context()->IsExtensionEnabled(WebGLExtensionID::OES_texture_float_linear)) { badFormatText = "FLOAT"; extText = "OES_texture_float_linear"; } else if (type == LOCAL_GL_HALF_FLOAT && !Context()->IsExtensionEnabled(WebGLExtensionID::OES_texture_half_float_linear)) { badFormatText = "HALF_FLOAT"; extText = "OES_texture_half_float_linear"; } const char* badFilterText = nullptr; if (badFormatText) { if (mMinFilter == LOCAL_GL_LINEAR || mMinFilter == LOCAL_GL_LINEAR_MIPMAP_LINEAR || mMinFilter == LOCAL_GL_LINEAR_MIPMAP_NEAREST || mMinFilter == LOCAL_GL_NEAREST_MIPMAP_LINEAR) { badFilterText = "minification"; } else if (mMagFilter == LOCAL_GL_LINEAR) { badFilterText = "magnification"; } } if (badFilterText) { mContext->GenerateWarning("%s is a texture with a linear %s filter," " which is not compatible with format %s by" " default. Try enabling the %s extension, if" " supported.", preamble, badFilterText, badFormatText, extText); mFakeBlackStatus = WebGLTextureFakeBlackStatus::IncompleteTexture; } // We have exhausted all cases of incomplete textures, where we would need opaque black. // We may still need transparent black in case of uninitialized image data. bool hasUninitializedImageData = false; for (size_t level = 0; level <= mMaxLevelWithCustomImages; ++level) { for (size_t face = 0; face < mFacesCount; ++face) { bool cur = (ImageInfoAtFace(face, level).mImageDataStatus == WebGLImageDataStatus::UninitializedImageData); hasUninitializedImageData |= cur; } } if (hasUninitializedImageData) { bool hasAnyInitializedImageData = false; for (size_t level = 0; level <= mMaxLevelWithCustomImages; ++level) { for (size_t face = 0; face < mFacesCount; ++face) { if (ImageInfoAtFace(face, level).mImageDataStatus == WebGLImageDataStatus::InitializedImageData) { hasAnyInitializedImageData = true; break; } } if (hasAnyInitializedImageData) { break; } } if (hasAnyInitializedImageData) { /* The texture contains some initialized image data, and some * uninitialized image data. In this case, we have no choice but to * initialize all image data now. Fortunately, in this case we know * that we can't be dealing with a depth texture per * WEBGL_depth_texture and ANGLE_depth_texture (which allow only one * image per texture) so we can assume that glTexImage2D is able to * upload data to images. */ for (size_t level = 0; level <= mMaxLevelWithCustomImages; ++level) { for (size_t face = 0; face < mFacesCount; ++face) { TexImageTarget imageTarget = TexImageTargetForTargetAndFace(mTarget, face); const ImageInfo& imageInfo = ImageInfoAt(imageTarget, level); if (imageInfo.mImageDataStatus == WebGLImageDataStatus::UninitializedImageData) { EnsureInitializedImageData(imageTarget, level); } } } mFakeBlackStatus = WebGLTextureFakeBlackStatus::NotNeeded; } else { // The texture only contains uninitialized image data. In this case, // we can use a black texture for it. mFakeBlackStatus = WebGLTextureFakeBlackStatus::UninitializedImageData; } } // we have exhausted all cases where we do need fakeblack, so if the status is still unknown, // that means that we do NOT need it. if (mFakeBlackStatus == WebGLTextureFakeBlackStatus::Unknown) { mFakeBlackStatus = WebGLTextureFakeBlackStatus::NotNeeded; } MOZ_ASSERT(mFakeBlackStatus != WebGLTextureFakeBlackStatus::Unknown); return mFakeBlackStatus; }