summaryrefslogtreecommitdiffstats
path: root/gfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp
diff options
context:
space:
mode:
authorwolfbeast <mcwerewolf@gmail.com>2018-07-11 18:11:13 +0200
committerwolfbeast <mcwerewolf@gmail.com>2018-07-11 18:11:13 +0200
commit4f2ecd53a9daaf88bb7d075745eefb6e2e4741e0 (patch)
treef000dd831240707a03b8c806db292c2a15cde3ce /gfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp
parent3b7ffb477eec078c7036c92c6a51bb5de6de4f28 (diff)
downloadUXP-4f2ecd53a9daaf88bb7d075745eefb6e2e4741e0.tar
UXP-4f2ecd53a9daaf88bb7d075745eefb6e2e4741e0.tar.gz
UXP-4f2ecd53a9daaf88bb7d075745eefb6e2e4741e0.tar.lz
UXP-4f2ecd53a9daaf88bb7d075745eefb6e2e4741e0.tar.xz
UXP-4f2ecd53a9daaf88bb7d075745eefb6e2e4741e0.zip
Roll back to ANGLE/2845
Diffstat (limited to 'gfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp')
-rwxr-xr-xgfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp472
1 files changed, 157 insertions, 315 deletions
diff --git a/gfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp b/gfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp
index 589580505..8b78bdc01 100755
--- a/gfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp
+++ b/gfx/angle/src/libANGLE/renderer/gl/TextureGL.cpp
@@ -8,7 +8,6 @@
#include "libANGLE/renderer/gl/TextureGL.h"
-#include "common/BitSetIterator.h"
#include "common/debug.h"
#include "common/utilities.h"
#include "libANGLE/State.h"
@@ -21,27 +20,21 @@
#include "libANGLE/renderer/gl/StateManagerGL.h"
#include "libANGLE/renderer/gl/WorkaroundsGL.h"
#include "libANGLE/renderer/gl/formatutilsgl.h"
-#include "libANGLE/renderer/gl/renderergl_utils.h"
-
-using angle::CheckedNumeric;
namespace rx
{
-namespace
-{
-
-bool UseTexImage2D(GLenum textureType)
+static bool UseTexImage2D(GLenum textureType)
{
return textureType == GL_TEXTURE_2D || textureType == GL_TEXTURE_CUBE_MAP;
}
-bool UseTexImage3D(GLenum textureType)
+static bool UseTexImage3D(GLenum textureType)
{
return textureType == GL_TEXTURE_2D_ARRAY || textureType == GL_TEXTURE_3D;
}
-bool CompatibleTextureTarget(GLenum textureType, GLenum textureTarget)
+static bool CompatibleTextureTarget(GLenum textureType, GLenum textureTarget)
{
if (textureType != GL_TEXTURE_CUBE_MAP)
{
@@ -53,13 +46,13 @@ bool CompatibleTextureTarget(GLenum textureType, GLenum textureTarget)
}
}
-bool IsLUMAFormat(GLenum format)
+static bool IsLUMAFormat(GLenum format)
{
return format == GL_LUMINANCE || format == GL_ALPHA || format == GL_LUMINANCE_ALPHA;
}
-LUMAWorkaroundGL GetLUMAWorkaroundInfo(const gl::InternalFormat &originalFormatInfo,
- GLenum destinationFormat)
+static LUMAWorkaroundGL GetLUMAWorkaroundInfo(const gl::InternalFormat &originalFormatInfo,
+ GLenum destinationFormat)
{
if (IsLUMAFormat(originalFormatInfo.format))
{
@@ -74,35 +67,23 @@ LUMAWorkaroundGL GetLUMAWorkaroundInfo(const gl::InternalFormat &originalFormatI
}
}
-bool IsDepthStencilFormat(GLenum format)
+static bool IsDepthStencilFormat(GLenum format)
{
return format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL;
}
-bool GetDepthStencilWorkaround(const gl::InternalFormat &originalFormatInfo)
+static bool GetDepthStencilWorkaround(const gl::InternalFormat &originalFormatInfo)
{
return IsDepthStencilFormat(originalFormatInfo.format);
}
-LevelInfoGL GetLevelInfo(GLenum originalFormat, GLenum destinationFormat)
+static LevelInfoGL GetLevelInfo(GLenum originalFormat, GLenum destinationFormat)
{
const gl::InternalFormat &originalFormatInfo = gl::GetInternalFormatInfo(originalFormat);
return LevelInfoGL(originalFormat, GetDepthStencilWorkaround(originalFormatInfo),
GetLUMAWorkaroundInfo(originalFormatInfo, destinationFormat));
}
-gl::Texture::DirtyBits GetLevelWorkaroundDirtyBits()
-{
- gl::Texture::DirtyBits bits;
- bits.set(gl::Texture::DIRTY_BIT_SWIZZLE_RED);
- bits.set(gl::Texture::DIRTY_BIT_SWIZZLE_GREEN);
- bits.set(gl::Texture::DIRTY_BIT_SWIZZLE_BLUE);
- bits.set(gl::Texture::DIRTY_BIT_SWIZZLE_ALPHA);
- return bits;
-}
-
-} // anonymous namespace
-
LUMAWorkaroundGL::LUMAWorkaroundGL() : LUMAWorkaroundGL(false, GL_NONE)
{
}
@@ -153,14 +134,8 @@ TextureGL::~TextureGL()
mTextureID = 0;
}
-gl::Error TextureGL::setImage(GLenum target,
- size_t level,
- GLenum internalFormat,
- const gl::Extents &size,
- GLenum format,
- GLenum type,
- const gl::PixelUnpackState &unpack,
- const uint8_t *pixels)
+gl::Error TextureGL::setImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size, GLenum format, GLenum type,
+ const gl::PixelUnpackState &unpack, const uint8_t *pixels)
{
if (mWorkarounds.unpackOverlappingRowsSeparatelyUnpackBuffer && unpack.pixelBuffer.get() &&
unpack.rowLength != 0 && unpack.rowLength < size.width)
@@ -168,41 +143,13 @@ gl::Error TextureGL::setImage(GLenum target,
// The rows overlap in unpack memory. Upload the texture row by row to work around
// driver bug.
reserveTexImageToBeFilled(target, level, internalFormat, size, format, type);
-
- if (size.width == 0 || size.height == 0 || size.depth == 0)
- {
- return gl::NoError();
- }
-
gl::Box area(0, 0, 0, size.width, size.height, size.depth);
- return setSubImageRowByRowWorkaround(target, level, area, format, type, unpack, pixels);
+ ANGLE_TRY(setSubImageRowByRowWorkaround(target, level, area, format, type, unpack, pixels));
}
-
- if (mWorkarounds.unpackLastRowSeparatelyForPaddingInclusion)
+ else
{
- bool apply;
- ANGLE_TRY_RESULT(ShouldApplyLastRowPaddingWorkaround(size, unpack, format, type,
- UseTexImage3D(mState.mTarget), pixels),
- apply);
-
- // The driver will think the pixel buffer doesn't have enough data, work around this bug
- // by uploading the last row (and last level if 3D) separately.
- if (apply)
- {
- reserveTexImageToBeFilled(target, level, internalFormat, size, format, type);
-
- if (size.width == 0 || size.height == 0 || size.depth == 0)
- {
- return gl::NoError();
- }
-
- gl::Box area(0, 0, 0, size.width, size.height, size.depth);
- return setSubImagePaddingWorkaround(target, level, area, format, type, unpack, pixels);
- }
+ setImageHelper(target, level, internalFormat, size, format, type, pixels);
}
-
- setImageHelper(target, level, internalFormat, size, format, type, pixels);
-
return gl::NoError();
}
@@ -214,6 +161,7 @@ void TextureGL::setImageHelper(GLenum target,
GLenum type,
const uint8_t *pixels)
{
+ UNUSED_ASSERTION_VARIABLE(&CompatibleTextureTarget); // Reference this function to avoid warnings.
ASSERT(CompatibleTextureTarget(mState.mTarget, target));
nativegl::TexImageFormat texImageFormat =
@@ -239,7 +187,7 @@ void TextureGL::setImageHelper(GLenum target,
UNREACHABLE();
}
- setLevelInfo(level, 1, GetLevelInfo(internalFormat, texImageFormat.internalFormat));
+ mLevelInfo[level] = GetLevelInfo(internalFormat, texImageFormat.internalFormat);
}
void TextureGL::reserveTexImageToBeFilled(GLenum target,
@@ -264,47 +212,32 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are
nativegl::TexSubImageFormat texSubImageFormat =
nativegl::GetTexSubImageFormat(mFunctions, mWorkarounds, format, type);
- ASSERT(mLevelInfo[level].lumaWorkaround.enabled ==
- GetLevelInfo(format, texSubImageFormat.format).lumaWorkaround.enabled);
-
mStateManager->bindTexture(mState.mTarget, mTextureID);
if (mWorkarounds.unpackOverlappingRowsSeparatelyUnpackBuffer && unpack.pixelBuffer.get() &&
unpack.rowLength != 0 && unpack.rowLength < area.width)
{
- return setSubImageRowByRowWorkaround(target, level, area, format, type, unpack, pixels);
- }
-
- if (mWorkarounds.unpackLastRowSeparatelyForPaddingInclusion)
- {
- gl::Extents size(area.width, area.height, area.depth);
-
- bool apply;
- ANGLE_TRY_RESULT(ShouldApplyLastRowPaddingWorkaround(size, unpack, format, type,
- UseTexImage3D(mState.mTarget), pixels),
- apply);
-
- // The driver will think the pixel buffer doesn't have enough data, work around this bug
- // by uploading the last row (and last level if 3D) separately.
- if (apply)
- {
- return setSubImagePaddingWorkaround(target, level, area, format, type, unpack, pixels);
- }
+ ANGLE_TRY(setSubImageRowByRowWorkaround(target, level, area, format, type, unpack, pixels));
}
-
- if (UseTexImage2D(mState.mTarget))
+ else if (UseTexImage2D(mState.mTarget))
{
ASSERT(area.z == 0 && area.depth == 1);
mFunctions->texSubImage2D(target, static_cast<GLint>(level), area.x, area.y, area.width,
area.height, texSubImageFormat.format, texSubImageFormat.type,
pixels);
}
- else
+ else if (UseTexImage3D(mState.mTarget))
{
- ASSERT(UseTexImage3D(mState.mTarget));
mFunctions->texSubImage3D(target, static_cast<GLint>(level), area.x, area.y, area.z,
area.width, area.height, area.depth, texSubImageFormat.format,
texSubImageFormat.type, pixels);
}
+ else
+ {
+ UNREACHABLE();
+ }
+
+ ASSERT(mLevelInfo[level].lumaWorkaround.enabled ==
+ GetLevelInfo(format, texSubImageFormat.format).lumaWorkaround.enabled);
return gl::Error(GL_NO_ERROR);
}
@@ -317,24 +250,26 @@ gl::Error TextureGL::setSubImageRowByRowWorkaround(GLenum target,
const gl::PixelUnpackState &unpack,
const uint8_t *pixels)
{
- gl::PixelUnpackState directUnpack;
- directUnpack.pixelBuffer = unpack.pixelBuffer;
- directUnpack.alignment = 1;
- mStateManager->setPixelUnpackState(directUnpack);
- directUnpack.pixelBuffer.set(nullptr);
-
- const gl::InternalFormat &glFormat =
- gl::GetInternalFormatInfo(gl::GetSizedInternalFormat(format, type));
- GLuint rowBytes = 0;
- ANGLE_TRY_RESULT(glFormat.computeRowPitch(area.width, unpack.alignment, unpack.rowLength),
- rowBytes);
+ gl::PixelUnpackState unpackToUse;
+ unpackToUse.pixelBuffer = unpack.pixelBuffer;
+ mStateManager->setPixelUnpackState(unpackToUse);
+ unpackToUse.pixelBuffer.set(nullptr);
+ const gl::Format &glFormat = mState.getImageDesc(mState.mTarget, level).format;
+ GLuint rowBytes = 0;
+ ANGLE_TRY_RESULT(
+ glFormat.info->computeRowPitch(GL_NONE, area.width, unpack.alignment, unpack.rowLength),
+ rowBytes);
GLuint imageBytes = 0;
- ANGLE_TRY_RESULT(gl::InternalFormat::computeDepthPitch(area.height, unpack.imageHeight, rowBytes),
- imageBytes);
+ ANGLE_TRY_RESULT(
+ glFormat.info->computeDepthPitch(GL_NONE, area.width, area.height, unpack.alignment,
+ unpack.rowLength, unpack.imageHeight),
+ imageBytes);
bool useTexImage3D = UseTexImage3D(mState.mTarget);
GLuint skipBytes = 0;
- ANGLE_TRY_RESULT(glFormat.computeSkipBytes(rowBytes, imageBytes, unpack, useTexImage3D),
- skipBytes);
+ ANGLE_TRY_RESULT(
+ glFormat.info->computeSkipBytes(rowBytes, imageBytes, unpack.skipImages, unpack.skipRows,
+ unpack.skipPixels, useTexImage3D),
+ skipBytes);
const uint8_t *pixelsWithSkip = pixels + skipBytes;
if (useTexImage3D)
@@ -352,9 +287,8 @@ gl::Error TextureGL::setSubImageRowByRowWorkaround(GLenum target,
}
}
}
- else
+ else if (UseTexImage2D(mState.mTarget))
{
- ASSERT(UseTexImage2D(mState.mTarget));
for (GLint row = 0; row < area.height; ++row)
{
GLint byteOffset = row * rowBytes;
@@ -363,89 +297,10 @@ gl::Error TextureGL::setSubImageRowByRowWorkaround(GLenum target,
area.width, 1, format, type, rowPixels);
}
}
- return gl::NoError();
-}
-
-gl::Error TextureGL::setSubImagePaddingWorkaround(GLenum target,
- size_t level,
- const gl::Box &area,
- GLenum format,
- GLenum type,
- const gl::PixelUnpackState &unpack,
- const uint8_t *pixels)
-{
- const gl::InternalFormat &glFormat =
- gl::GetInternalFormatInfo(gl::GetSizedInternalFormat(format, type));
- GLuint rowBytes = 0;
- ANGLE_TRY_RESULT(glFormat.computeRowPitch(area.width, unpack.alignment, unpack.rowLength),
- rowBytes);
- GLuint imageBytes = 0;
- ANGLE_TRY_RESULT(gl::InternalFormat::computeDepthPitch(area.height, unpack.imageHeight, rowBytes),
- imageBytes);
- bool useTexImage3D = UseTexImage3D(mState.mTarget);
- GLuint skipBytes = 0;
- ANGLE_TRY_RESULT(glFormat.computeSkipBytes(rowBytes, imageBytes, unpack, useTexImage3D),
- skipBytes);
-
- gl::PixelUnpackState directUnpack;
- directUnpack.pixelBuffer = unpack.pixelBuffer;
- directUnpack.alignment = 1;
-
- if (useTexImage3D)
- {
- // Upload all but the last slice
- if (area.depth > 1)
- {
- mFunctions->texSubImage3D(target, static_cast<GLint>(level), area.x, area.y, area.z,
- area.width, area.height, area.depth - 1, format, type,
- pixels);
- }
-
- // Upload the last slice but its last row
- if (area.height > 1)
- {
- // Do not include skipBytes in the last image pixel start offset as it will be done by
- // the driver
- GLint lastImageOffset = (area.depth - 1) * imageBytes;
- const GLubyte *lastImagePixels = pixels + lastImageOffset;
- mFunctions->texSubImage3D(target, static_cast<GLint>(level), area.x, area.y,
- area.z + area.depth - 1, area.width, area.height - 1, 1,
- format, type, lastImagePixels);
- }
-
- // Upload the last row of the last slice "manually"
- mStateManager->setPixelUnpackState(directUnpack);
-
- GLint lastRowOffset =
- skipBytes + (area.depth - 1) * imageBytes + (area.height - 1) * rowBytes;
- const GLubyte *lastRowPixels = pixels + lastRowOffset;
- mFunctions->texSubImage3D(target, static_cast<GLint>(level), area.x,
- area.y + area.height - 1, area.z + area.depth - 1, area.width, 1,
- 1, format, type, lastRowPixels);
- }
else
{
- ASSERT(UseTexImage2D(mState.mTarget));
-
- // Upload all but the last row
- if (area.height > 1)
- {
- mFunctions->texSubImage2D(target, static_cast<GLint>(level), area.x, area.y, area.width,
- area.height - 1, format, type, pixels);
- }
-
- // Upload the last row "manually"
- mStateManager->setPixelUnpackState(directUnpack);
-
- GLint lastRowOffset = skipBytes + (area.height - 1) * rowBytes;
- const GLubyte *lastRowPixels = pixels + lastRowOffset;
- mFunctions->texSubImage2D(target, static_cast<GLint>(level), area.x,
- area.y + area.height - 1, area.width, 1, format, type,
- lastRowPixels);
+ UNREACHABLE();
}
-
- directUnpack.pixelBuffer.set(nullptr);
-
return gl::NoError();
}
@@ -476,7 +331,7 @@ gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum inte
UNREACHABLE();
}
- setLevelInfo(level, 1, GetLevelInfo(internalFormat, compressedTexImageFormat.internalFormat));
+ mLevelInfo[level] = GetLevelInfo(internalFormat, compressedTexImageFormat.internalFormat);
ASSERT(!mLevelInfo[level].lumaWorkaround.enabled);
return gl::Error(GL_NO_ERROR);
@@ -553,7 +408,7 @@ gl::Error TextureGL::copyImage(GLenum target, size_t level, const gl::Rectangle
}
}
- setLevelInfo(level, 1, levelInfo);
+ mLevelInfo[level] = levelInfo;
return gl::Error(GL_NO_ERROR);
}
@@ -639,7 +494,8 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
if (internalFormatInfo.compressed)
{
GLuint dataSize = 0;
- ANGLE_TRY_RESULT(internalFormatInfo.computeCompressedImageSize(levelSize),
+ ANGLE_TRY_RESULT(internalFormatInfo.computeCompressedImageSize(
+ GL_UNSIGNED_BYTE, levelSize),
dataSize);
mFunctions->compressedTexImage2D(target, static_cast<GLint>(level),
texStorageFormat.internalFormat,
@@ -662,7 +518,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
{
GLuint dataSize = 0;
ANGLE_TRY_RESULT(internalFormatInfo.computeCompressedImageSize(
- levelSize),
+ GL_UNSIGNED_BYTE, levelSize),
dataSize);
mFunctions->compressedTexImage2D(
face, static_cast<GLint>(level), texStorageFormat.internalFormat,
@@ -713,7 +569,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
{
GLuint dataSize = 0;
ANGLE_TRY_RESULT(
- internalFormatInfo.computeCompressedImageSize(levelSize),
+ internalFormatInfo.computeCompressedImageSize(GL_UNSIGNED_BYTE, levelSize),
dataSize);
mFunctions->compressedTexImage3D(target, i, texStorageFormat.internalFormat,
levelSize.width, levelSize.height,
@@ -735,7 +591,11 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
UNREACHABLE();
}
- setLevelInfo(0, levels, GetLevelInfo(internalFormat, texStorageFormat.internalFormat));
+ LevelInfoGL levelInfo = GetLevelInfo(internalFormat, texStorageFormat.internalFormat);
+ for (size_t level = 0; level < mLevelInfo.size(); level++)
+ {
+ mLevelInfo[level] = levelInfo;
+ }
return gl::Error(GL_NO_ERROR);
}
@@ -750,6 +610,8 @@ gl::Error TextureGL::setImageExternal(GLenum target,
gl::Error TextureGL::generateMipmap()
{
+ // Need to sync base level and max level to driver before calling GenerateMipmap.
+ syncState(0);
mStateManager->bindTexture(mState.mTarget, mTextureID);
mFunctions->generateMipmap(mState.mTarget);
@@ -758,7 +620,10 @@ gl::Error TextureGL::generateMipmap()
ASSERT(maxLevel < mLevelInfo.size());
- setLevelInfo(effectiveBaseLevel, maxLevel - effectiveBaseLevel, mLevelInfo[effectiveBaseLevel]);
+ for (GLuint level = effectiveBaseLevel; level <= maxLevel; level++)
+ {
+ mLevelInfo[level] = mLevelInfo[effectiveBaseLevel];
+ }
return gl::Error(GL_NO_ERROR);
}
@@ -770,7 +635,7 @@ void TextureGL::bindTexImage(egl::Surface *surface)
// Make sure this texture is bound
mStateManager->bindTexture(mState.mTarget, mTextureID);
- setLevelInfo(0, 1, LevelInfoGL());
+ mLevelInfo[0] = LevelInfoGL();
}
void TextureGL::releaseTexImage()
@@ -796,121 +661,58 @@ gl::Error TextureGL::setEGLImageTarget(GLenum target, egl::Image *image)
return gl::Error(GL_INVALID_OPERATION);
}
-void TextureGL::syncState(const gl::Texture::DirtyBits &dirtyBits)
+template <typename T, typename ApplyTextureFuncType>
+static inline void SyncSamplerStateMember(const FunctionsGL *functions,
+ ApplyTextureFuncType applyTextureFunc,
+ const gl::SamplerState &newState,
+ gl::SamplerState &curState,
+ GLenum textureType,
+ GLenum name,
+ T(gl::SamplerState::*samplerMember))
{
- if (dirtyBits.none() && mLocalDirtyBits.none())
- {
- return;
- }
-
- mStateManager->bindTexture(mState.mTarget, mTextureID);
-
- if (dirtyBits[gl::Texture::DIRTY_BIT_BASE_LEVEL] || dirtyBits[gl::Texture::DIRTY_BIT_MAX_LEVEL])
+ if (curState.*samplerMember != newState.*samplerMember)
{
- // Don't know if the previous base level was using any workarounds, always re-sync the
- // workaround dirty bits
- mLocalDirtyBits |= GetLevelWorkaroundDirtyBits();
+ applyTextureFunc();
+ curState.*samplerMember = newState.*samplerMember;
+ functions->texParameterf(textureType, name, static_cast<GLfloat>(curState.*samplerMember));
}
-
- for (auto dirtyBit : angle::IterateBitSet(dirtyBits | mLocalDirtyBits))
- {
- switch (dirtyBit)
- {
- case gl::Texture::DIRTY_BIT_MIN_FILTER:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MIN_FILTER,
- mState.getSamplerState().minFilter);
- break;
- case gl::Texture::DIRTY_BIT_MAG_FILTER:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MAG_FILTER,
- mState.getSamplerState().magFilter);
- break;
- case gl::Texture::DIRTY_BIT_WRAP_S:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_WRAP_S,
- mState.getSamplerState().wrapS);
- break;
- case gl::Texture::DIRTY_BIT_WRAP_T:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_WRAP_T,
- mState.getSamplerState().wrapT);
- break;
- case gl::Texture::DIRTY_BIT_WRAP_R:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_WRAP_R,
- mState.getSamplerState().wrapR);
- break;
- case gl::Texture::DIRTY_BIT_MAX_ANISOTROPY:
- mFunctions->texParameterf(mState.mTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT,
- mState.getSamplerState().maxAnisotropy);
- break;
- case gl::Texture::DIRTY_BIT_MIN_LOD:
- mFunctions->texParameterf(mState.mTarget, GL_TEXTURE_MIN_LOD,
- mState.getSamplerState().minLod);
- break;
- case gl::Texture::DIRTY_BIT_MAX_LOD:
- mFunctions->texParameterf(mState.mTarget, GL_TEXTURE_MAX_LOD,
- mState.getSamplerState().maxLod);
- break;
- case gl::Texture::DIRTY_BIT_COMPARE_MODE:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_COMPARE_MODE,
- mState.getSamplerState().compareMode);
- break;
- case gl::Texture::DIRTY_BIT_COMPARE_FUNC:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_COMPARE_FUNC,
- mState.getSamplerState().compareFunc);
- break;
- case gl::Texture::DIRTY_BIT_SRGB_DECODE:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_SRGB_DECODE_EXT,
- mState.getSamplerState().sRGBDecode);
- break;
-
- // Texture state
- case gl::Texture::DIRTY_BIT_SWIZZLE_RED:
- syncTextureStateSwizzle(mFunctions, GL_TEXTURE_SWIZZLE_R,
- mState.getSwizzleState().swizzleRed);
- break;
- case gl::Texture::DIRTY_BIT_SWIZZLE_GREEN:
- syncTextureStateSwizzle(mFunctions, GL_TEXTURE_SWIZZLE_G,
- mState.getSwizzleState().swizzleGreen);
- break;
- case gl::Texture::DIRTY_BIT_SWIZZLE_BLUE:
- syncTextureStateSwizzle(mFunctions, GL_TEXTURE_SWIZZLE_B,
- mState.getSwizzleState().swizzleBlue);
- break;
- case gl::Texture::DIRTY_BIT_SWIZZLE_ALPHA:
- syncTextureStateSwizzle(mFunctions, GL_TEXTURE_SWIZZLE_A,
- mState.getSwizzleState().swizzleAlpha);
- break;
- case gl::Texture::DIRTY_BIT_BASE_LEVEL:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_BASE_LEVEL,
- mState.getEffectiveBaseLevel());
- break;
- case gl::Texture::DIRTY_BIT_MAX_LEVEL:
- mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MAX_LEVEL,
- mState.getEffectiveMaxLevel());
- break;
- case gl::Texture::DIRTY_BIT_USAGE:
- break;
-
- default:
- UNREACHABLE();
- }
- }
-
- mLocalDirtyBits.reset();
}
-bool TextureGL::hasAnyDirtyBit() const
+template <typename T, typename ApplyTextureFuncType>
+static inline void SyncTextureStateMember(const FunctionsGL *functions,
+ ApplyTextureFuncType applyTextureFunc,
+ const gl::TextureState &newState,
+ gl::TextureState &curState,
+ GLenum textureType,
+ GLenum name,
+ T(gl::TextureState::*stateMember))
{
- return mLocalDirtyBits.any();
+ if (curState.*stateMember != newState.*stateMember)
+ {
+ applyTextureFunc();
+ curState.*stateMember = newState.*stateMember;
+ functions->texParameterf(textureType, name, static_cast<GLfloat>(curState.*stateMember));
+ }
}
-void TextureGL::syncTextureStateSwizzle(const FunctionsGL *functions, GLenum name, GLenum value)
+template <typename T, typename ApplyTextureFuncType>
+static inline void SyncTextureStateSwizzle(const FunctionsGL *functions,
+ ApplyTextureFuncType applyTextureFunc,
+ const LevelInfoGL &levelInfo,
+ const gl::SwizzleState &newState,
+ gl::SwizzleState &curState,
+ GLenum textureType,
+ GLenum name,
+ T(gl::SwizzleState::*stateMember))
{
- const LevelInfoGL &levelInfo = mLevelInfo[mState.getEffectiveBaseLevel()];
- GLenum resultSwizzle = value;
+ GLenum resultSwizzle = newState.*stateMember;
if (levelInfo.lumaWorkaround.enabled || levelInfo.depthStencilWorkaround)
{
if (levelInfo.lumaWorkaround.enabled)
{
- switch (value)
+ UNUSED_ASSERTION_VARIABLE(levelInfo.lumaWorkaround.workaroundFormat);
+
+ switch (newState.*stateMember)
{
case GL_RED:
case GL_GREEN:
@@ -964,7 +766,7 @@ void TextureGL::syncTextureStateSwizzle(const FunctionsGL *functions, GLenum nam
case GL_ZERO:
case GL_ONE:
// Don't modify the swizzle state when requesting ZERO or ONE.
- resultSwizzle = value;
+ resultSwizzle = newState.*stateMember;
break;
default:
@@ -974,11 +776,11 @@ void TextureGL::syncTextureStateSwizzle(const FunctionsGL *functions, GLenum nam
}
else if (levelInfo.depthStencilWorkaround)
{
- switch (value)
+ switch (newState.*stateMember)
{
case GL_RED:
// Don't modify the swizzle state when requesting the red channel.
- resultSwizzle = value;
+ resultSwizzle = newState.*stateMember;
break;
case GL_GREEN:
@@ -995,7 +797,7 @@ void TextureGL::syncTextureStateSwizzle(const FunctionsGL *functions, GLenum nam
case GL_ZERO:
case GL_ONE:
// Don't modify the swizzle state when requesting ZERO or ONE.
- resultSwizzle = value;
+ resultSwizzle = newState.*stateMember;
break;
default:
@@ -1010,25 +812,65 @@ void TextureGL::syncTextureStateSwizzle(const FunctionsGL *functions, GLenum nam
}
- functions->texParameteri(mState.mTarget, name, resultSwizzle);
+ if (curState.*stateMember != resultSwizzle)
+ {
+ applyTextureFunc();
+ curState.*stateMember = resultSwizzle;
+ functions->texParameterf(textureType, name, static_cast<GLfloat>(resultSwizzle));
+ }
}
-void TextureGL::setLevelInfo(size_t level, size_t levelCount, const LevelInfoGL &levelInfo)
+void TextureGL::syncState(size_t textureUnit) const
{
- ASSERT(levelCount > 0 && level + levelCount < mLevelInfo.size());
+ // Callback lamdba to bind this texture only if needed.
+ bool textureApplied = false;
+ auto applyTextureFunc = [&]()
+ {
+ if (!textureApplied)
+ {
+ mStateManager->activeTexture(textureUnit);
+ mStateManager->bindTexture(mState.mTarget, mTextureID);
+ textureApplied = true;
+ }
+ };
- GLuint baseLevel = mState.getEffectiveBaseLevel();
- bool needsResync = level <= baseLevel && level + levelCount >= baseLevel &&
- (levelInfo.depthStencilWorkaround || levelInfo.lumaWorkaround.enabled);
- if (needsResync)
+ // Sync texture state
+ // Apply the effective base level and max level instead of the base level and max level set from
+ // the API. This can help with buggy drivers.
+ if (mAppliedTextureState.getEffectiveBaseLevel() != mState.getEffectiveBaseLevel())
{
- mLocalDirtyBits |= GetLevelWorkaroundDirtyBits();
+ applyTextureFunc();
+ mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_BASE_LEVEL,
+ mState.getEffectiveBaseLevel());
}
-
- for (size_t i = level; i < level + levelCount; i++)
+ mAppliedTextureState.mBaseLevel = mState.mBaseLevel;
+ if (mAppliedTextureState.getEffectiveMaxLevel() != mState.getEffectiveMaxLevel())
{
- mLevelInfo[i] = levelInfo;
+ applyTextureFunc();
+ mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MAX_LEVEL,
+ mState.getEffectiveMaxLevel());
}
+ mAppliedTextureState.mMaxLevel = mState.mMaxLevel;
+
+ // clang-format off
+ const LevelInfoGL &levelInfo = mLevelInfo[mState.getEffectiveBaseLevel()];
+ SyncTextureStateSwizzle(mFunctions, applyTextureFunc, levelInfo, mState.mSwizzleState, mAppliedTextureState.mSwizzleState, mState.mTarget, GL_TEXTURE_SWIZZLE_R, &gl::SwizzleState::swizzleRed);
+ SyncTextureStateSwizzle(mFunctions, applyTextureFunc, levelInfo, mState.mSwizzleState, mAppliedTextureState.mSwizzleState, mState.mTarget, GL_TEXTURE_SWIZZLE_G, &gl::SwizzleState::swizzleGreen);
+ SyncTextureStateSwizzle(mFunctions, applyTextureFunc, levelInfo, mState.mSwizzleState, mAppliedTextureState.mSwizzleState, mState.mTarget, GL_TEXTURE_SWIZZLE_B, &gl::SwizzleState::swizzleBlue);
+ SyncTextureStateSwizzle(mFunctions, applyTextureFunc, levelInfo, mState.mSwizzleState, mAppliedTextureState.mSwizzleState, mState.mTarget, GL_TEXTURE_SWIZZLE_A, &gl::SwizzleState::swizzleAlpha);
+
+ // Sync sampler state
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_MIN_FILTER, &gl::SamplerState::minFilter);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_MAG_FILTER, &gl::SamplerState::magFilter);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_WRAP_S, &gl::SamplerState::wrapS);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_WRAP_T, &gl::SamplerState::wrapT);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_WRAP_R, &gl::SamplerState::wrapR);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, &gl::SamplerState::maxAnisotropy);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_MIN_LOD, &gl::SamplerState::minLod);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_MAX_LOD, &gl::SamplerState::maxLod);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_COMPARE_MODE, &gl::SamplerState::compareMode);
+ SyncSamplerStateMember(mFunctions, applyTextureFunc, mState.mSamplerState, mAppliedTextureState.mSamplerState, mState.mTarget, GL_TEXTURE_COMPARE_FUNC, &gl::SamplerState::compareFunc);
+ // clang-format on
}
GLuint TextureGL::getTextureID() const