Skip to content

A
angle
Commit 133a2ecb by Corentin Wallez Committed by Commit Bot
Options

Implement CHROMIUM_copy_texture for OpenGL.

This also makes BlitGL work correctly on OpenGL ES (provided vertex arrays are available) BUG=angleproject:1356 Change-Id: Icb7cef35bebfe6672220aa0b312ab89187dbf585 Reviewed-on: https://chromium-review.googlesource.com/412452 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 6c1cbf51
Showing with 408 additions and 96 deletions
src/libANGLE/renderer/gl/BlitGL.cpp
...@@ -27,6 +27,7 @@ gl::Error CheckCompileStatus(const rx::FunctionsGL *functions, GLuint shader) ...@@ -27,6 +27,7 @@ gl::Error CheckCompileStatus(const rx::FunctionsGL *functions, GLuint shader)
{ {
GLint compileStatus = GL_FALSE; GLint compileStatus = GL_FALSE;
functions->getShaderiv(shader, GL_COMPILE_STATUS, &compileStatus); functions->getShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
ASSERT(compileStatus == GL_TRUE); ASSERT(compileStatus == GL_TRUE);
if (compileStatus == GL_FALSE) if (compileStatus == GL_FALSE)
{ {
...@@ -114,8 +115,11 @@ BlitGL::BlitGL(const FunctionsGL *functions, ...@@ -114,8 +115,11 @@ BlitGL::BlitGL(const FunctionsGL *functions,
mSourceTextureLocation(-1), mSourceTextureLocation(-1),
mScaleLocation(-1), mScaleLocation(-1),
mOffsetLocation(-1), mOffsetLocation(-1),
mMultiplyAlphaLocation(-1),
mUnMultiplyAlphaLocation(-1),
mScratchFBO(0), mScratchFBO(0),
mVAO(0) mVAO(0),
mVertexBuffer(0)
{ {
for (size_t i = 0; i < ArraySize(mScratchTextures); i++) for (size_t i = 0; i < ArraySize(mScratchTextures); i++)
{ {
...@@ -169,6 +173,9 @@ gl::Error BlitGL::copyImageToLUMAWorkaroundTexture(GLuint texture, ...@@ -169,6 +173,9 @@ gl::Error BlitGL::copyImageToLUMAWorkaroundTexture(GLuint texture,
// Allocate the texture memory // Allocate the texture memory
const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat); const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat);
gl::PixelUnpackState unpack;
mStateManager->setPixelUnpackState(unpack);
mFunctions->texImage2D(target, static_cast<GLint>(level), internalFormat, sourceArea.width, mFunctions->texImage2D(target, static_cast<GLint>(level), internalFormat, sourceArea.width,
sourceArea.height, 0, internalFormatInfo.format, sourceArea.height, 0, internalFormatInfo.format,
source->getImplementationColorReadType(), nullptr); source->getImplementationColorReadType(), nullptr);
...@@ -223,7 +230,7 @@ gl::Error BlitGL::copySubImageToLUMAWorkaroundTexture(GLuint texture, ...@@ -223,7 +230,7 @@ gl::Error BlitGL::copySubImageToLUMAWorkaroundTexture(GLuint texture,
// Render to the destination texture, sampling from the scratch texture // Render to the destination texture, sampling from the scratch texture
ScopedGLState scopedState(mStateManager, mFunctions, ScopedGLState scopedState(mStateManager, mFunctions,
gl::Rectangle(0, 0, sourceArea.width, sourceArea.height)); gl::Rectangle(0, 0, sourceArea.width, sourceArea.height));
scopedState.willUseTextureUnit(0); scopedState.willUseTextureUnit(0);
setScratchTextureParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST); setScratchTextureParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST);
...@@ -236,9 +243,10 @@ gl::Error BlitGL::copySubImageToLUMAWorkaroundTexture(GLuint texture, ...@@ -236,9 +243,10 @@ gl::Error BlitGL::copySubImageToLUMAWorkaroundTexture(GLuint texture,
mFunctions->uniform1i(mSourceTextureLocation, 0); mFunctions->uniform1i(mSourceTextureLocation, 0);
mFunctions->uniform2f(mScaleLocation, 1.0, 1.0); mFunctions->uniform2f(mScaleLocation, 1.0, 1.0);
mFunctions->uniform2f(mOffsetLocation, 0.0, 0.0); mFunctions->uniform2f(mOffsetLocation, 0.0, 0.0);
mFunctions->uniform1i(mMultiplyAlphaLocation, 0);
mFunctions->uniform1i(mUnMultiplyAlphaLocation, 0);
mStateManager->bindVertexArray(mVAO, 0); mStateManager->bindVertexArray(mVAO, 0);
mFunctions->drawArrays(GL_TRIANGLES, 0, 3); mFunctions->drawArrays(GL_TRIANGLES, 0, 3);
// Copy the swizzled texture to the destination texture // Copy the swizzled texture to the destination texture
...@@ -405,6 +413,8 @@ gl::Error BlitGL::blitColorBufferWithShader(const gl::Framebuffer *source, ...@@ -405,6 +413,8 @@ gl::Error BlitGL::blitColorBufferWithShader(const gl::Framebuffer *source,
mFunctions->uniform1i(mSourceTextureLocation, 0); mFunctions->uniform1i(mSourceTextureLocation, 0);
mFunctions->uniform2f(mScaleLocation, texCoordScale.x, texCoordScale.y); mFunctions->uniform2f(mScaleLocation, texCoordScale.x, texCoordScale.y);
mFunctions->uniform2f(mOffsetLocation, texCoordOffset.x, texCoordOffset.y); mFunctions->uniform2f(mOffsetLocation, texCoordOffset.x, texCoordOffset.y);
mFunctions->uniform1i(mMultiplyAlphaLocation, 0);
mFunctions->uniform1i(mUnMultiplyAlphaLocation, 0);
const FramebufferGL *destGL = GetImplAs<FramebufferGL>(dest); const FramebufferGL *destGL = GetImplAs<FramebufferGL>(dest);
mStateManager->bindFramebuffer(GL_DRAW_FRAMEBUFFER, destGL->getFramebufferID()); mStateManager->bindFramebuffer(GL_DRAW_FRAMEBUFFER, destGL->getFramebufferID());
...@@ -415,6 +425,107 @@ gl::Error BlitGL::blitColorBufferWithShader(const gl::Framebuffer *source, ...@@ -415,6 +425,107 @@ gl::Error BlitGL::blitColorBufferWithShader(const gl::Framebuffer *source,
return gl::NoError(); return gl::NoError();
} }
gl::Error BlitGL::copySubTexture(TextureGL *source,
TextureGL *dest,
const gl::Extents &sourceSize,
const gl::Rectangle &sourceArea,
const gl::Offset &destOffset,
bool needsLumaWorkaround,
GLenum lumaFormat,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha)
{
ANGLE_TRY(initializeResources());
// Setup the source texture
if (needsLumaWorkaround)
{
GLint luminance = (lumaFormat == GL_ALPHA) ? GL_ZERO : GL_RED;
GLint alpha = GL_RED;
if (lumaFormat == GL_LUMINANCE)
{
alpha = GL_ONE;
}
else if (lumaFormat == GL_LUMINANCE_ALPHA)
{
alpha = GL_GREEN;
}
else
{
ASSERT(lumaFormat == GL_ALPHA);
}
GLint swizzle[4] = {luminance, luminance, luminance, alpha};
source->setSwizzle(swizzle);
}
source->setMinFilter(GL_NEAREST);
source->setMagFilter(GL_NEAREST);
// Render to the destination texture, sampling from the source texture
ScopedGLState scopedState(
mStateManager, mFunctions,
gl::Rectangle(destOffset.x, destOffset.y, sourceArea.width, sourceArea.height));
scopedState.willUseTextureUnit(0);
mStateManager->activeTexture(0);
mStateManager->bindTexture(GL_TEXTURE_2D, source->getTextureID());
gl::Vector2 scale(sourceArea.width / static_cast<float>(sourceSize.width),
sourceArea.height / static_cast<float>(sourceSize.height));
gl::Vector2 offset(sourceArea.x / static_cast<float>(sourceSize.width),
sourceArea.y / static_cast<float>(sourceSize.height));
if (unpackFlipY)
{
offset.y += scale.y;
scale.y = -scale.y;
}
mStateManager->useProgram(mBlitProgram);
mFunctions->uniform1i(mSourceTextureLocation, 0);
mFunctions->uniform2f(mScaleLocation, scale.x, scale.y);
mFunctions->uniform2f(mOffsetLocation, offset.x, offset.y);
if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha)
{
mFunctions->uniform1i(mMultiplyAlphaLocation, 0);
mFunctions->uniform1i(mUnMultiplyAlphaLocation, 0);
}
else
{
mFunctions->uniform1i(mMultiplyAlphaLocation, unpackPremultiplyAlpha);
mFunctions->uniform1i(mUnMultiplyAlphaLocation, unpackUnmultiplyAlpha);
}
mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mScratchFBO);
mFunctions->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dest->getTarget(),
dest->getTextureID(), 0);
mStateManager->bindVertexArray(mVAO, 0);
mFunctions->drawArrays(GL_TRIANGLES, 0, 3);
return gl::NoError();
}
gl::Error BlitGL::copyTexSubImage(TextureGL *source,
TextureGL *dest,
const gl::Rectangle &sourceArea,
const gl::Offset &destOffset)
{
ANGLE_TRY(initializeResources());
mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mScratchFBO);
mFunctions->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
source->getTextureID(), 0);
mStateManager->bindTexture(dest->getTarget(), dest->getTextureID());
mFunctions->copyTexSubImage2D(dest->getTarget(), 0, destOffset.x, destOffset.y, sourceArea.x,
sourceArea.y, sourceArea.width, sourceArea.height);
return gl::NoError();
}
gl::Error BlitGL::initializeResources() gl::Error BlitGL::initializeResources()
{ {
if (mBlitProgram == 0) if (mBlitProgram == 0)
...@@ -422,25 +533,17 @@ gl::Error BlitGL::initializeResources() ...@@ -422,25 +533,17 @@ gl::Error BlitGL::initializeResources()
mBlitProgram = mFunctions->createProgram(); mBlitProgram = mFunctions->createProgram();
// Compile the fragment shader // Compile the fragment shader
// It uses a single, large triangle, to avoid arithmetic precision issues where fragments
// with the same Y coordinate don't get exactly the same interpolated texcoord Y.
const char *vsSource = const char *vsSource =
"#version 150\n" "#version 100\n"
"out vec2 v_texcoord;\n" "varying vec2 v_texcoord;\n"
"uniform vec2 u_scale;\n" "uniform vec2 u_scale;\n"
"uniform vec2 u_offset;\n" "uniform vec2 u_offset;\n"
"attribute vec2 a_texcoord;\n"
"\n" "\n"
"void main()\n" "void main()\n"
"{\n" "{\n"
" const vec2 quad_positions[3] = vec2[3]\n" " gl_Position = vec4((a_texcoord * 2.0) - 1.0, 0.0, 1.0);\n"
" (\n" " v_texcoord = a_texcoord * u_scale + u_offset;\n"
" vec2(-0.5f, 0.0f),\n"
" vec2( 1.5f, 0.0f),\n"
" vec2( 0.5f, 2.0f)\n"
" );\n"
"\n"
" gl_Position = vec4((quad_positions[gl_VertexID] * 2.0) - 1.0, 0.0, 1.0);\n"
" v_texcoord = quad_positions[gl_VertexID] * u_scale + u_offset;\n"
"}\n"; "}\n";
GLuint vs = mFunctions->createShader(GL_VERTEX_SHADER); GLuint vs = mFunctions->createShader(GL_VERTEX_SHADER);
...@@ -455,10 +558,12 @@ gl::Error BlitGL::initializeResources() ...@@ -455,10 +558,12 @@ gl::Error BlitGL::initializeResources()
// It discards if the texcoord is outside (0, 1)^2 so the blitframebuffer workaround // It discards if the texcoord is outside (0, 1)^2 so the blitframebuffer workaround
// doesn't write when the point sampled is outside of the source framebuffer. // doesn't write when the point sampled is outside of the source framebuffer.
const char *fsSource = const char *fsSource =
"#version 150\n" "#version 100\n"
"precision highp float;"
"uniform sampler2D u_source_texture;\n" "uniform sampler2D u_source_texture;\n"
"in vec2 v_texcoord;\n" "uniform bool u_multiply_alpha;\n"
"out vec4 output_color;\n" "uniform bool u_unmultiply_alpha;\n"
"varying vec2 v_texcoord;\n"
"\n" "\n"
"void main()\n" "void main()\n"
"{\n" "{\n"
...@@ -466,7 +571,10 @@ gl::Error BlitGL::initializeResources() ...@@ -466,7 +571,10 @@ gl::Error BlitGL::initializeResources()
" {\n" " {\n"
" discard;\n" " discard;\n"
" }\n" " }\n"
" output_color = texture(u_source_texture, v_texcoord);\n" " vec4 color = texture2D(u_source_texture, v_texcoord);\n"
" if (u_multiply_alpha) {color.xyz = color.xyz * color.a;}"
" if (u_unmultiply_alpha && color.a != 0.0) {color.xyz = color.xyz / color.a;}"
" gl_FragColor = color;"
"}\n"; "}\n";
GLuint fs = mFunctions->createShader(GL_FRAGMENT_SHADER); GLuint fs = mFunctions->createShader(GL_FRAGMENT_SHADER);
...@@ -480,10 +588,13 @@ gl::Error BlitGL::initializeResources() ...@@ -480,10 +588,13 @@ gl::Error BlitGL::initializeResources()
mFunctions->linkProgram(mBlitProgram); mFunctions->linkProgram(mBlitProgram);
ANGLE_TRY(CheckLinkStatus(mFunctions, mBlitProgram)); ANGLE_TRY(CheckLinkStatus(mFunctions, mBlitProgram));
mTexCoordAttributeLocation = mFunctions->getAttribLocation(mBlitProgram, "a_texcoord");
mSourceTextureLocation = mFunctions->getUniformLocation(mBlitProgram, "u_source_texture"); mSourceTextureLocation = mFunctions->getUniformLocation(mBlitProgram, "u_source_texture");
mScaleLocation = mFunctions->getUniformLocation(mBlitProgram, "u_scale"); mScaleLocation = mFunctions->getUniformLocation(mBlitProgram, "u_scale");
mOffsetLocation = mFunctions->getUniformLocation(mBlitProgram, "u_offset"); mOffsetLocation = mFunctions->getUniformLocation(mBlitProgram, "u_offset");
mStateManager->useProgram(mBlitProgram); mMultiplyAlphaLocation = mFunctions->getUniformLocation(mBlitProgram, "u_multiply_alpha");
mUnMultiplyAlphaLocation =
mFunctions->getUniformLocation(mBlitProgram, "u_unmultiply_alpha");
} }
for (size_t i = 0; i < ArraySize(mScratchTextures); i++) for (size_t i = 0; i < ArraySize(mScratchTextures); i++)
...@@ -499,9 +610,29 @@ gl::Error BlitGL::initializeResources() ...@@ -499,9 +610,29 @@ gl::Error BlitGL::initializeResources()
mFunctions->genFramebuffers(1, &mScratchFBO); mFunctions->genFramebuffers(1, &mScratchFBO);
} }
if (mVertexBuffer == 0)
{
mFunctions->genBuffers(1, &mVertexBuffer);
mStateManager->bindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
// Use a single, large triangle, to avoid arithmetic precision issues where fragments
// with the same Y coordinate don't get exactly the same interpolated texcoord Y.
float vertexData[] = {
-0.5f, 0.0f, 1.5f, 0.0f, 0.5f, 2.0f,
};
mFunctions->bufferData(GL_ARRAY_BUFFER, sizeof(float) * 6, vertexData, GL_STATIC_DRAW);
}
if (mVAO == 0) if (mVAO == 0)
{ {
mFunctions->genVertexArrays(1, &mVAO); mFunctions->genVertexArrays(1, &mVAO);
mStateManager->bindVertexArray(mVAO, 0);
mStateManager->bindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
mFunctions->enableVertexAttribArray(mTexCoordAttributeLocation);
mFunctions->vertexAttribPointer(mTexCoordAttributeLocation, 2, GL_FLOAT, GL_FALSE, 0,
nullptr);
} }
return gl::NoError(); return gl::NoError();
...@@ -512,6 +643,8 @@ void BlitGL::orphanScratchTextures() ...@@ -512,6 +643,8 @@ void BlitGL::orphanScratchTextures()
for (auto texture : mScratchTextures) for (auto texture : mScratchTextures)
{ {
mStateManager->bindTexture(GL_TEXTURE_2D, texture); mStateManager->bindTexture(GL_TEXTURE_2D, texture);
gl::PixelUnpackState unpack;
mStateManager->setPixelUnpackState(unpack);
mFunctions->texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, mFunctions->texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE,
nullptr); nullptr);
} }
......
src/libANGLE/renderer/gl/BlitGL.h
...@@ -25,6 +25,7 @@ namespace rx ...@@ -25,6 +25,7 @@ namespace rx
class FramebufferGL; class FramebufferGL;
class FunctionsGL; class FunctionsGL;
class StateManagerGL; class StateManagerGL;
class TextureGL;
struct WorkaroundsGL; struct WorkaroundsGL;
class BlitGL : public angle::NonCopyable class BlitGL : public angle::NonCopyable
...@@ -43,6 +44,7 @@ class BlitGL : public angle::NonCopyable ...@@ -43,6 +44,7 @@ class BlitGL : public angle::NonCopyable
const gl::Rectangle &sourceArea, const gl::Rectangle &sourceArea,
GLenum internalFormat, GLenum internalFormat,
const gl::Framebuffer *source); const gl::Framebuffer *source);
gl::Error copySubImageToLUMAWorkaroundTexture(GLuint texture, gl::Error copySubImageToLUMAWorkaroundTexture(GLuint texture,
GLenum textureType, GLenum textureType,
GLenum target, GLenum target,
...@@ -58,6 +60,22 @@ class BlitGL : public angle::NonCopyable ...@@ -58,6 +60,22 @@ class BlitGL : public angle::NonCopyable
const gl::Rectangle &destArea, const gl::Rectangle &destArea,
GLenum filter); GLenum filter);
gl::Error copySubTexture(TextureGL *source,
TextureGL *dest,
const gl::Extents &sourceSize,
const gl::Rectangle &sourceArea,
const gl::Offset &destOffset,
bool needsLumaWorkaround,
GLenum lumaFormat,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha);
gl::Error copyTexSubImage(TextureGL *source,
TextureGL *dest,
const gl::Rectangle &sourceArea,
const gl::Offset &destOffset);
gl::Error initializeResources(); gl::Error initializeResources();
private: private:
...@@ -69,14 +87,18 @@ class BlitGL : public angle::NonCopyable ...@@ -69,14 +87,18 @@ class BlitGL : public angle::NonCopyable
StateManagerGL *mStateManager; StateManagerGL *mStateManager;
GLuint mBlitProgram; GLuint mBlitProgram;
GLint mTexCoordAttributeLocation;
GLint mSourceTextureLocation; GLint mSourceTextureLocation;
GLint mScaleLocation; GLint mScaleLocation;
GLint mOffsetLocation; GLint mOffsetLocation;
GLint mMultiplyAlphaLocation;
GLint mUnMultiplyAlphaLocation;
GLuint mScratchTextures[2]; GLuint mScratchTextures[2];
GLuint mScratchFBO; GLuint mScratchFBO;
GLuint mVAO; GLuint mVAO;
GLuint mVertexBuffer;
}; };
} }
......
src/libANGLE/renderer/gl/TextureGL.cpp
...@@ -147,7 +147,7 @@ TextureGL::TextureGL(const gl::TextureState &state, ...@@ -147,7 +147,7 @@ TextureGL::TextureGL(const gl::TextureState &state,
ASSERT(mBlitter); ASSERT(mBlitter);
mFunctions->genTextures(1, &mTextureID); mFunctions->genTextures(1, &mTextureID);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
} }
TextureGL::~TextureGL() TextureGL::~TextureGL()
...@@ -185,7 +185,7 @@ gl::Error TextureGL::setImage(GLenum target, ...@@ -185,7 +185,7 @@ gl::Error TextureGL::setImage(GLenum target,
{ {
bool apply; bool apply;
ANGLE_TRY_RESULT(ShouldApplyLastRowPaddingWorkaround(size, unpack, format, type, ANGLE_TRY_RESULT(ShouldApplyLastRowPaddingWorkaround(size, unpack, format, type,
UseTexImage3D(mState.mTarget), pixels), UseTexImage3D(getTarget()), pixels),
apply); apply);
// The driver will think the pixel buffer doesn't have enough data, work around this bug // The driver will think the pixel buffer doesn't have enough data, work around this bug
...@@ -217,21 +217,21 @@ void TextureGL::setImageHelper(GLenum target, ...@@ -217,21 +217,21 @@ void TextureGL::setImageHelper(GLenum target,
GLenum type, GLenum type,
const uint8_t *pixels) const uint8_t *pixels)
{ {
ASSERT(CompatibleTextureTarget(mState.mTarget, target)); ASSERT(CompatibleTextureTarget(getTarget(), target));
nativegl::TexImageFormat texImageFormat = nativegl::TexImageFormat texImageFormat =
nativegl::GetTexImageFormat(mFunctions, mWorkarounds, internalFormat, format, type); nativegl::GetTexImageFormat(mFunctions, mWorkarounds, internalFormat, format, type);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
ASSERT(size.depth == 1); ASSERT(size.depth == 1);
mFunctions->texImage2D(target, static_cast<GLint>(level), texImageFormat.internalFormat, mFunctions->texImage2D(target, static_cast<GLint>(level), texImageFormat.internalFormat,
size.width, size.height, 0, texImageFormat.format, size.width, size.height, 0, texImageFormat.format,
texImageFormat.type, pixels); texImageFormat.type, pixels);
} }
else if (UseTexImage3D(mState.mTarget)) else if (UseTexImage3D(getTarget()))
{ {
mFunctions->texImage3D(target, static_cast<GLint>(level), texImageFormat.internalFormat, mFunctions->texImage3D(target, static_cast<GLint>(level), texImageFormat.internalFormat,
size.width, size.height, size.depth, 0, texImageFormat.format, size.width, size.height, size.depth, 0, texImageFormat.format,
...@@ -252,17 +252,15 @@ void TextureGL::reserveTexImageToBeFilled(GLenum target, ...@@ -252,17 +252,15 @@ void TextureGL::reserveTexImageToBeFilled(GLenum target,
GLenum format, GLenum format,
GLenum type) GLenum type)
{ {
GLuint unpackBuffer = mStateManager->getBoundBuffer(GL_PIXEL_UNPACK_BUFFER);
mStateManager->bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
gl::PixelUnpackState unpack; gl::PixelUnpackState unpack;
mStateManager->setPixelUnpackState(unpack);
setImageHelper(target, level, internalFormat, size, format, type, nullptr); setImageHelper(target, level, internalFormat, size, format, type, nullptr);
mStateManager->bindBuffer(GL_PIXEL_UNPACK_BUFFER, unpackBuffer);
} }
gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format, GLenum type, gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format, GLenum type,
const gl::PixelUnpackState &unpack, const uint8_t *pixels) const gl::PixelUnpackState &unpack, const uint8_t *pixels)
{ {
ASSERT(CompatibleTextureTarget(mState.mTarget, target)); ASSERT(CompatibleTextureTarget(getTarget(), target));
nativegl::TexSubImageFormat texSubImageFormat = nativegl::TexSubImageFormat texSubImageFormat =
nativegl::GetTexSubImageFormat(mFunctions, mWorkarounds, format, type); nativegl::GetTexSubImageFormat(mFunctions, mWorkarounds, format, type);
...@@ -270,7 +268,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are ...@@ -270,7 +268,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are
ASSERT(mLevelInfo[level].lumaWorkaround.enabled == ASSERT(mLevelInfo[level].lumaWorkaround.enabled ==
GetLevelInfo(format, texSubImageFormat.format).lumaWorkaround.enabled); GetLevelInfo(format, texSubImageFormat.format).lumaWorkaround.enabled);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
if (mWorkarounds.unpackOverlappingRowsSeparatelyUnpackBuffer && unpack.pixelBuffer.get() && if (mWorkarounds.unpackOverlappingRowsSeparatelyUnpackBuffer && unpack.pixelBuffer.get() &&
unpack.rowLength != 0 && unpack.rowLength < area.width) unpack.rowLength != 0 && unpack.rowLength < area.width)
{ {
...@@ -283,7 +281,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are ...@@ -283,7 +281,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are
bool apply; bool apply;
ANGLE_TRY_RESULT(ShouldApplyLastRowPaddingWorkaround(size, unpack, format, type, ANGLE_TRY_RESULT(ShouldApplyLastRowPaddingWorkaround(size, unpack, format, type,
UseTexImage3D(mState.mTarget), pixels), UseTexImage3D(getTarget()), pixels),
apply); apply);
// The driver will think the pixel buffer doesn't have enough data, work around this bug // The driver will think the pixel buffer doesn't have enough data, work around this bug
...@@ -294,7 +292,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are ...@@ -294,7 +292,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are
} }
} }
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
ASSERT(area.z == 0 && area.depth == 1); ASSERT(area.z == 0 && area.depth == 1);
mFunctions->texSubImage2D(target, static_cast<GLint>(level), area.x, area.y, area.width, mFunctions->texSubImage2D(target, static_cast<GLint>(level), area.x, area.y, area.width,
...@@ -303,7 +301,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are ...@@ -303,7 +301,7 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are
} }
else else
{ {
ASSERT(UseTexImage3D(mState.mTarget)); ASSERT(UseTexImage3D(getTarget()));
mFunctions->texSubImage3D(target, static_cast<GLint>(level), area.x, area.y, area.z, mFunctions->texSubImage3D(target, static_cast<GLint>(level), area.x, area.y, area.z,
area.width, area.height, area.depth, texSubImageFormat.format, area.width, area.height, area.depth, texSubImageFormat.format,
texSubImageFormat.type, pixels); texSubImageFormat.type, pixels);
...@@ -334,7 +332,7 @@ gl::Error TextureGL::setSubImageRowByRowWorkaround(GLenum target, ...@@ -334,7 +332,7 @@ gl::Error TextureGL::setSubImageRowByRowWorkaround(GLenum target,
GLuint imageBytes = 0; GLuint imageBytes = 0;
ANGLE_TRY_RESULT(glFormat.computeDepthPitch(area.height, unpack.imageHeight, rowBytes), ANGLE_TRY_RESULT(glFormat.computeDepthPitch(area.height, unpack.imageHeight, rowBytes),
imageBytes); imageBytes);
bool useTexImage3D = UseTexImage3D(mState.mTarget); bool useTexImage3D = UseTexImage3D(getTarget());
GLuint skipBytes = 0; GLuint skipBytes = 0;
ANGLE_TRY_RESULT(glFormat.computeSkipBytes(rowBytes, imageBytes, unpack, useTexImage3D), ANGLE_TRY_RESULT(glFormat.computeSkipBytes(rowBytes, imageBytes, unpack, useTexImage3D),
skipBytes); skipBytes);
...@@ -357,7 +355,7 @@ gl::Error TextureGL::setSubImageRowByRowWorkaround(GLenum target, ...@@ -357,7 +355,7 @@ gl::Error TextureGL::setSubImageRowByRowWorkaround(GLenum target,
} }
else else
{ {
ASSERT(UseTexImage2D(mState.mTarget)); ASSERT(UseTexImage2D(getTarget()));
for (GLint row = 0; row < area.height; ++row) for (GLint row = 0; row < area.height; ++row)
{ {
GLint byteOffset = row * rowBytes; GLint byteOffset = row * rowBytes;
...@@ -385,11 +383,13 @@ gl::Error TextureGL::setSubImagePaddingWorkaround(GLenum target, ...@@ -385,11 +383,13 @@ gl::Error TextureGL::setSubImagePaddingWorkaround(GLenum target,
GLuint imageBytes = 0; GLuint imageBytes = 0;
ANGLE_TRY_RESULT(glFormat.computeDepthPitch(area.height, unpack.imageHeight, rowBytes), ANGLE_TRY_RESULT(glFormat.computeDepthPitch(area.height, unpack.imageHeight, rowBytes),
imageBytes); imageBytes);
bool useTexImage3D = UseTexImage3D(mState.mTarget); bool useTexImage3D = UseTexImage3D(getTarget());
GLuint skipBytes = 0; GLuint skipBytes = 0;
ANGLE_TRY_RESULT(glFormat.computeSkipBytes(rowBytes, imageBytes, unpack, useTexImage3D), ANGLE_TRY_RESULT(glFormat.computeSkipBytes(rowBytes, imageBytes, unpack, useTexImage3D),
skipBytes); skipBytes);
mStateManager->setPixelUnpackState(unpack);
gl::PixelUnpackState directUnpack; gl::PixelUnpackState directUnpack;
directUnpack.pixelBuffer = unpack.pixelBuffer; directUnpack.pixelBuffer = unpack.pixelBuffer;
directUnpack.alignment = 1; directUnpack.alignment = 1;
...@@ -428,7 +428,7 @@ gl::Error TextureGL::setSubImagePaddingWorkaround(GLenum target, ...@@ -428,7 +428,7 @@ gl::Error TextureGL::setSubImagePaddingWorkaround(GLenum target,
} }
else else
{ {
ASSERT(UseTexImage2D(mState.mTarget)); ASSERT(UseTexImage2D(getTarget()));
// Upload all but the last row // Upload all but the last row
if (area.height > 1) if (area.height > 1)
...@@ -455,20 +455,20 @@ gl::Error TextureGL::setSubImagePaddingWorkaround(GLenum target, ...@@ -455,20 +455,20 @@ gl::Error TextureGL::setSubImagePaddingWorkaround(GLenum target,
gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size, gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size,
const gl::PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels) const gl::PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels)
{ {
ASSERT(CompatibleTextureTarget(mState.mTarget, target)); ASSERT(CompatibleTextureTarget(getTarget(), target));
nativegl::CompressedTexImageFormat compressedTexImageFormat = nativegl::CompressedTexImageFormat compressedTexImageFormat =
nativegl::GetCompressedTexImageFormat(mFunctions, mWorkarounds, internalFormat); nativegl::GetCompressedTexImageFormat(mFunctions, mWorkarounds, internalFormat);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
ASSERT(size.depth == 1); ASSERT(size.depth == 1);
mFunctions->compressedTexImage2D(target, static_cast<GLint>(level), mFunctions->compressedTexImage2D(target, static_cast<GLint>(level),
compressedTexImageFormat.internalFormat, size.width, compressedTexImageFormat.internalFormat, size.width,
size.height, 0, static_cast<GLsizei>(imageSize), pixels); size.height, 0, static_cast<GLsizei>(imageSize), pixels);
} }
else if (UseTexImage3D(mState.mTarget)) else if (UseTexImage3D(getTarget()))
{ {
mFunctions->compressedTexImage3D( mFunctions->compressedTexImage3D(
target, static_cast<GLint>(level), compressedTexImageFormat.internalFormat, size.width, target, static_cast<GLint>(level), compressedTexImageFormat.internalFormat, size.width,
...@@ -488,20 +488,20 @@ gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum inte ...@@ -488,20 +488,20 @@ gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum inte
gl::Error TextureGL::setCompressedSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format, gl::Error TextureGL::setCompressedSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format,
const gl::PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels) const gl::PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels)
{ {
ASSERT(CompatibleTextureTarget(mState.mTarget, target)); ASSERT(CompatibleTextureTarget(getTarget(), target));
nativegl::CompressedTexSubImageFormat compressedTexSubImageFormat = nativegl::CompressedTexSubImageFormat compressedTexSubImageFormat =
nativegl::GetCompressedSubTexImageFormat(mFunctions, mWorkarounds, format); nativegl::GetCompressedSubTexImageFormat(mFunctions, mWorkarounds, format);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
ASSERT(area.z == 0 && area.depth == 1); ASSERT(area.z == 0 && area.depth == 1);
mFunctions->compressedTexSubImage2D( mFunctions->compressedTexSubImage2D(
target, static_cast<GLint>(level), area.x, area.y, area.width, area.height, target, static_cast<GLint>(level), area.x, area.y, area.width, area.height,
compressedTexSubImageFormat.format, static_cast<GLsizei>(imageSize), pixels); compressedTexSubImageFormat.format, static_cast<GLsizei>(imageSize), pixels);
} }
else if (UseTexImage3D(mState.mTarget)) else if (UseTexImage3D(getTarget()))
{ {
mFunctions->compressedTexSubImage3D(target, static_cast<GLint>(level), area.x, area.y, mFunctions->compressedTexSubImage3D(target, static_cast<GLint>(level), area.x, area.y,
area.z, area.width, area.height, area.depth, area.z, area.width, area.height, area.depth,
...@@ -529,7 +529,7 @@ gl::Error TextureGL::copyImage(GLenum target, size_t level, const gl::Rectangle ...@@ -529,7 +529,7 @@ gl::Error TextureGL::copyImage(GLenum target, size_t level, const gl::Rectangle
if (levelInfo.lumaWorkaround.enabled) if (levelInfo.lumaWorkaround.enabled)
{ {
gl::Error error = mBlitter->copyImageToLUMAWorkaroundTexture( gl::Error error = mBlitter->copyImageToLUMAWorkaroundTexture(
mTextureID, mState.mTarget, target, levelInfo.sourceFormat, level, sourceArea, mTextureID, getTarget(), target, levelInfo.sourceFormat, level, sourceArea,
copyTexImageFormat.internalFormat, source); copyTexImageFormat.internalFormat, source);
if (error.isError()) if (error.isError())
{ {
...@@ -540,11 +540,11 @@ gl::Error TextureGL::copyImage(GLenum target, size_t level, const gl::Rectangle ...@@ -540,11 +540,11 @@ gl::Error TextureGL::copyImage(GLenum target, size_t level, const gl::Rectangle
{ {
const FramebufferGL *sourceFramebufferGL = GetImplAs<FramebufferGL>(source); const FramebufferGL *sourceFramebufferGL = GetImplAs<FramebufferGL>(source);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
mStateManager->bindFramebuffer(GL_READ_FRAMEBUFFER, mStateManager->bindFramebuffer(GL_READ_FRAMEBUFFER,
sourceFramebufferGL->getFramebufferID()); sourceFramebufferGL->getFramebufferID());
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
mFunctions->copyTexImage2D(target, static_cast<GLint>(level), mFunctions->copyTexImage2D(target, static_cast<GLint>(level),
copyTexImageFormat.internalFormat, sourceArea.x, copyTexImageFormat.internalFormat, sourceArea.x,
...@@ -566,15 +566,15 @@ gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset ...@@ -566,15 +566,15 @@ gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset
{ {
const FramebufferGL *sourceFramebufferGL = GetImplAs<FramebufferGL>(source); const FramebufferGL *sourceFramebufferGL = GetImplAs<FramebufferGL>(source);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
mStateManager->bindFramebuffer(GL_READ_FRAMEBUFFER, sourceFramebufferGL->getFramebufferID()); mStateManager->bindFramebuffer(GL_READ_FRAMEBUFFER, sourceFramebufferGL->getFramebufferID());
const LevelInfoGL &levelInfo = mLevelInfo[level]; const LevelInfoGL &levelInfo = mLevelInfo[level];
if (levelInfo.lumaWorkaround.enabled) if (levelInfo.lumaWorkaround.enabled)
{ {
gl::Error error = mBlitter->copySubImageToLUMAWorkaroundTexture( gl::Error error = mBlitter->copySubImageToLUMAWorkaroundTexture(
mTextureID, mState.mTarget, target, levelInfo.sourceFormat, level, destOffset, mTextureID, getTarget(), target, levelInfo.sourceFormat, level, destOffset, sourceArea,
sourceArea, source); source);
if (error.isError()) if (error.isError())
{ {
return error; return error;
...@@ -582,14 +582,14 @@ gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset ...@@ -582,14 +582,14 @@ gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset
} }
else else
{ {
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
ASSERT(destOffset.z == 0); ASSERT(destOffset.z == 0);
mFunctions->copyTexSubImage2D(target, static_cast<GLint>(level), destOffset.x, mFunctions->copyTexSubImage2D(target, static_cast<GLint>(level), destOffset.x,
destOffset.y, sourceArea.x, sourceArea.y, destOffset.y, sourceArea.x, sourceArea.y,
sourceArea.width, sourceArea.height); sourceArea.width, sourceArea.height);
} }
else if (UseTexImage3D(mState.mTarget)) else if (UseTexImage3D(getTarget()))
{ {
mFunctions->copyTexSubImage3D(target, static_cast<GLint>(level), destOffset.x, mFunctions->copyTexSubImage3D(target, static_cast<GLint>(level), destOffset.x,
destOffset.y, destOffset.z, sourceArea.x, sourceArea.y, destOffset.y, destOffset.z, sourceArea.x, sourceArea.y,
...@@ -604,16 +604,79 @@ gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset ...@@ -604,16 +604,79 @@ gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset
return gl::Error(GL_NO_ERROR); return gl::Error(GL_NO_ERROR);
} }
gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFormat, const gl::Extents &size) gl::Error TextureGL::copyTexture(GLenum internalFormat,
GLenum type,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
const gl::Texture *source)
{
const TextureGL *sourceGL = GetImplAs<TextureGL>(source);
const gl::ImageDesc &sourceImageDesc = sourceGL->mState.getImageDesc(source->getTarget(), 0);
gl::Rectangle sourceArea(0, 0, sourceImageDesc.size.width, sourceImageDesc.size.height);
GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalFormat, type);
reserveTexImageToBeFilled(getTarget(), 0, sizedInternalFormat, sourceImageDesc.size,
internalFormat, type);
return copySubTextureHelper(gl::Offset(0, 0, 0), sourceArea, internalFormat, unpackFlipY,
unpackPremultiplyAlpha, unpackUnmultiplyAlpha, source);
}
gl::Error TextureGL::copySubTexture(const gl::Offset &destOffset,
const gl::Rectangle &sourceArea,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
const gl::Texture *source)
{ {
// TODO: emulate texture storage with TexImage calls if on GL version <4.2 or the GLenum destFormat = mState.getImageDesc(mState.mTarget, 0).format.format;
// ARB_texture_storage extension is not available. return copySubTextureHelper(destOffset, sourceArea, destFormat, unpackFlipY,
unpackPremultiplyAlpha, unpackUnmultiplyAlpha, source);
}
gl::Error TextureGL::copySubTextureHelper(const gl::Offset &destOffset,
const gl::Rectangle &sourceArea,
GLenum destFormat,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
const gl::Texture *source)
{
TextureGL *sourceGL = GetImplAs<TextureGL>(source);
const gl::ImageDesc &sourceImageDesc = sourceGL->mState.getImageDesc(source->getTarget(), 0);
// Check is this is a simple copySubTexture that can be done with a copyTexSubImage
bool needsLumaWorkaround = sourceGL->mLevelInfo[0].lumaWorkaround.enabled;
GLenum sourceFormat = sourceImageDesc.format.format;
bool sourceFormatContainSupersetOfDestFormat =
(sourceFormat == destFormat && sourceFormat != GL_BGRA_EXT) ||
(sourceFormat == GL_RGBA && destFormat == GL_RGB);
if (source->getTarget() == GL_TEXTURE_2D && getTarget() == GL_TEXTURE_2D && !unpackFlipY &&
unpackPremultiplyAlpha == unpackUnmultiplyAlpha && !needsLumaWorkaround &&
sourceFormatContainSupersetOfDestFormat)
{
return mBlitter->copyTexSubImage(sourceGL, this, sourceArea, destOffset);
}
// We can't use copyTexSubImage, do a manual copy
return mBlitter->copySubTexture(sourceGL, this, sourceImageDesc.size, sourceArea, destOffset,
needsLumaWorkaround, sourceGL->mLevelInfo[0].sourceFormat,
unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}
gl::Error TextureGL::setStorage(GLenum target,
size_t levels,
GLenum internalFormat,
const gl::Extents &size)
{
nativegl::TexStorageFormat texStorageFormat = nativegl::TexStorageFormat texStorageFormat =
nativegl::GetTexStorageFormat(mFunctions, mWorkarounds, internalFormat); nativegl::GetTexStorageFormat(mFunctions, mWorkarounds, internalFormat);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
ASSERT(size.depth == 1); ASSERT(size.depth == 1);
if (mFunctions->texStorage2D) if (mFunctions->texStorage2D)
...@@ -637,7 +700,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor ...@@ -637,7 +700,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
std::max(size.height >> level, 1), std::max(size.height >> level, 1),
1); 1);
if (mState.mTarget == GL_TEXTURE_2D) if (getTarget() == GL_TEXTURE_2D)
{ {
if (internalFormatInfo.compressed) if (internalFormatInfo.compressed)
{ {
...@@ -658,7 +721,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor ...@@ -658,7 +721,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
internalFormatInfo.type, nullptr); internalFormatInfo.type, nullptr);
} }
} }
else if (mState.mTarget == GL_TEXTURE_CUBE_MAP) else if (getTarget() == GL_TEXTURE_CUBE_MAP)
{ {
for (GLenum face = gl::FirstCubeMapTextureTarget; face <= gl::LastCubeMapTextureTarget; face++) for (GLenum face = gl::FirstCubeMapTextureTarget; face <= gl::LastCubeMapTextureTarget; face++)
{ {
...@@ -689,7 +752,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor ...@@ -689,7 +752,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
} }
} }
} }
else if (UseTexImage3D(mState.mTarget)) else if (UseTexImage3D(getTarget()))
{ {
if (mFunctions->texStorage3D) if (mFunctions->texStorage3D)
{ {
...@@ -711,7 +774,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor ...@@ -711,7 +774,7 @@ gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFor
{ {
gl::Extents levelSize( gl::Extents levelSize(
std::max(size.width >> i, 1), std::max(size.height >> i, 1), std::max(size.width >> i, 1), std::max(size.height >> i, 1),
mState.mTarget == GL_TEXTURE_3D ? std::max(size.depth >> i, 1) : size.depth); getTarget() == GL_TEXTURE_3D ? std::max(size.depth >> i, 1) : size.depth);
if (internalFormatInfo.compressed) if (internalFormatInfo.compressed)
{ {
...@@ -754,8 +817,8 @@ gl::Error TextureGL::setImageExternal(GLenum target, ...@@ -754,8 +817,8 @@ gl::Error TextureGL::setImageExternal(GLenum target,
gl::Error TextureGL::generateMipmap() gl::Error TextureGL::generateMipmap()
{ {
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
mFunctions->generateMipmap(mState.mTarget); mFunctions->generateMipmap(getTarget());
const GLuint effectiveBaseLevel = mState.getEffectiveBaseLevel(); const GLuint effectiveBaseLevel = mState.getEffectiveBaseLevel();
const GLuint maxLevel = mState.getMipmapMaxLevel(); const GLuint maxLevel = mState.getMipmapMaxLevel();
...@@ -769,10 +832,10 @@ gl::Error TextureGL::generateMipmap() ...@@ -769,10 +832,10 @@ gl::Error TextureGL::generateMipmap()
void TextureGL::bindTexImage(egl::Surface *surface) void TextureGL::bindTexImage(egl::Surface *surface)
{ {
ASSERT(mState.mTarget == GL_TEXTURE_2D); ASSERT(getTarget() == GL_TEXTURE_2D);
// Make sure this texture is bound // Make sure this texture is bound
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
setLevelInfo(0, 1, LevelInfoGL()); setLevelInfo(0, 1, LevelInfoGL());
} }
...@@ -780,12 +843,12 @@ void TextureGL::bindTexImage(egl::Surface *surface) ...@@ -780,12 +843,12 @@ void TextureGL::bindTexImage(egl::Surface *surface)
void TextureGL::releaseTexImage() void TextureGL::releaseTexImage()
{ {
// Not all Surface implementations reset the size of mip 0 when releasing, do it manually // Not all Surface implementations reset the size of mip 0 when releasing, do it manually
ASSERT(mState.mTarget == GL_TEXTURE_2D); ASSERT(getTarget() == GL_TEXTURE_2D);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
if (UseTexImage2D(mState.mTarget)) if (UseTexImage2D(getTarget()))
{ {
mFunctions->texImage2D(mState.mTarget, 0, GL_RGBA, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, mFunctions->texImage2D(getTarget(), 0, GL_RGBA, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE,
nullptr); nullptr);
} }
else else
...@@ -807,7 +870,7 @@ void TextureGL::syncState(const gl::Texture::DirtyBits &dirtyBits) ...@@ -807,7 +870,7 @@ void TextureGL::syncState(const gl::Texture::DirtyBits &dirtyBits)
return; return;
} }
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
if (dirtyBits[gl::Texture::DIRTY_BIT_BASE_LEVEL] || dirtyBits[gl::Texture::DIRTY_BIT_MAX_LEVEL]) if (dirtyBits[gl::Texture::DIRTY_BIT_BASE_LEVEL] || dirtyBits[gl::Texture::DIRTY_BIT_MAX_LEVEL])
{ {
...@@ -822,54 +885,52 @@ void TextureGL::syncState(const gl::Texture::DirtyBits &dirtyBits) ...@@ -822,54 +885,52 @@ void TextureGL::syncState(const gl::Texture::DirtyBits &dirtyBits)
{ {
case gl::Texture::DIRTY_BIT_MIN_FILTER: case gl::Texture::DIRTY_BIT_MIN_FILTER:
mAppliedSampler.minFilter = mState.getSamplerState().minFilter; mAppliedSampler.minFilter = mState.getSamplerState().minFilter;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MIN_FILTER, mFunctions->texParameteri(getTarget(), GL_TEXTURE_MIN_FILTER,
mAppliedSampler.minFilter); mAppliedSampler.minFilter);
break; break;
case gl::Texture::DIRTY_BIT_MAG_FILTER: case gl::Texture::DIRTY_BIT_MAG_FILTER:
mAppliedSampler.magFilter = mState.getSamplerState().magFilter; mAppliedSampler.magFilter = mState.getSamplerState().magFilter;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MAG_FILTER, mFunctions->texParameteri(getTarget(), GL_TEXTURE_MAG_FILTER,
mAppliedSampler.magFilter); mAppliedSampler.magFilter);
break; break;
case gl::Texture::DIRTY_BIT_WRAP_S: case gl::Texture::DIRTY_BIT_WRAP_S:
mAppliedSampler.wrapS = mState.getSamplerState().wrapS; mAppliedSampler.wrapS = mState.getSamplerState().wrapS;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_WRAP_S, mAppliedSampler.wrapS); mFunctions->texParameteri(getTarget(), GL_TEXTURE_WRAP_S, mAppliedSampler.wrapS);
break; break;
case gl::Texture::DIRTY_BIT_WRAP_T: case gl::Texture::DIRTY_BIT_WRAP_T:
mAppliedSampler.wrapT = mState.getSamplerState().wrapT; mAppliedSampler.wrapT = mState.getSamplerState().wrapT;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_WRAP_T, mAppliedSampler.wrapT); mFunctions->texParameteri(getTarget(), GL_TEXTURE_WRAP_T, mAppliedSampler.wrapT);
break; break;
case gl::Texture::DIRTY_BIT_WRAP_R: case gl::Texture::DIRTY_BIT_WRAP_R:
mAppliedSampler.wrapR = mState.getSamplerState().wrapR; mAppliedSampler.wrapR = mState.getSamplerState().wrapR;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_WRAP_R, mAppliedSampler.wrapR); mFunctions->texParameteri(getTarget(), GL_TEXTURE_WRAP_R, mAppliedSampler.wrapR);
break; break;
case gl::Texture::DIRTY_BIT_MAX_ANISOTROPY: case gl::Texture::DIRTY_BIT_MAX_ANISOTROPY:
mAppliedSampler.maxAnisotropy = mState.getSamplerState().maxAnisotropy; mAppliedSampler.maxAnisotropy = mState.getSamplerState().maxAnisotropy;
mFunctions->texParameterf(mState.mTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, mFunctions->texParameterf(getTarget(), GL_TEXTURE_MAX_ANISOTROPY_EXT,
mAppliedSampler.maxAnisotropy); mAppliedSampler.maxAnisotropy);
break; break;
case gl::Texture::DIRTY_BIT_MIN_LOD: case gl::Texture::DIRTY_BIT_MIN_LOD:
mAppliedSampler.minLod = mState.getSamplerState().minLod; mAppliedSampler.minLod = mState.getSamplerState().minLod;
mFunctions->texParameterf(mState.mTarget, GL_TEXTURE_MIN_LOD, mFunctions->texParameterf(getTarget(), GL_TEXTURE_MIN_LOD, mAppliedSampler.minLod);
mAppliedSampler.minLod);
break; break;
case gl::Texture::DIRTY_BIT_MAX_LOD: case gl::Texture::DIRTY_BIT_MAX_LOD:
mAppliedSampler.maxLod = mState.getSamplerState().maxLod; mAppliedSampler.maxLod = mState.getSamplerState().maxLod;
mFunctions->texParameterf(mState.mTarget, GL_TEXTURE_MAX_LOD, mFunctions->texParameterf(getTarget(), GL_TEXTURE_MAX_LOD, mAppliedSampler.maxLod);
mAppliedSampler.maxLod);
break; break;
case gl::Texture::DIRTY_BIT_COMPARE_MODE: case gl::Texture::DIRTY_BIT_COMPARE_MODE:
mAppliedSampler.compareMode = mState.getSamplerState().compareMode; mAppliedSampler.compareMode = mState.getSamplerState().compareMode;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_COMPARE_MODE, mFunctions->texParameteri(getTarget(), GL_TEXTURE_COMPARE_MODE,
mAppliedSampler.compareMode); mAppliedSampler.compareMode);
break; break;
case gl::Texture::DIRTY_BIT_COMPARE_FUNC: case gl::Texture::DIRTY_BIT_COMPARE_FUNC:
mAppliedSampler.compareFunc = mState.getSamplerState().compareFunc; mAppliedSampler.compareFunc = mState.getSamplerState().compareFunc;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_COMPARE_FUNC, mFunctions->texParameteri(getTarget(), GL_TEXTURE_COMPARE_FUNC,
mAppliedSampler.compareFunc); mAppliedSampler.compareFunc);
break; break;
case gl::Texture::DIRTY_BIT_SRGB_DECODE: case gl::Texture::DIRTY_BIT_SRGB_DECODE:
mAppliedSampler.sRGBDecode = mState.getSamplerState().sRGBDecode; mAppliedSampler.sRGBDecode = mState.getSamplerState().sRGBDecode;
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_SRGB_DECODE_EXT, mFunctions->texParameteri(getTarget(), GL_TEXTURE_SRGB_DECODE_EXT,
mAppliedSampler.sRGBDecode); mAppliedSampler.sRGBDecode);
break; break;
...@@ -896,11 +957,11 @@ void TextureGL::syncState(const gl::Texture::DirtyBits &dirtyBits) ...@@ -896,11 +957,11 @@ void TextureGL::syncState(const gl::Texture::DirtyBits &dirtyBits)
break; break;
case gl::Texture::DIRTY_BIT_BASE_LEVEL: case gl::Texture::DIRTY_BIT_BASE_LEVEL:
mAppliedBaseLevel = mState.getEffectiveBaseLevel(); mAppliedBaseLevel = mState.getEffectiveBaseLevel();
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_BASE_LEVEL, mAppliedBaseLevel); mFunctions->texParameteri(getTarget(), GL_TEXTURE_BASE_LEVEL, mAppliedBaseLevel);
break; break;
case gl::Texture::DIRTY_BIT_MAX_LEVEL: case gl::Texture::DIRTY_BIT_MAX_LEVEL:
mAppliedMaxLevel = mState.getEffectiveMaxLevel(); mAppliedMaxLevel = mState.getEffectiveMaxLevel();
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MAX_LEVEL, mAppliedMaxLevel); mFunctions->texParameteri(getTarget(), GL_TEXTURE_MAX_LEVEL, mAppliedMaxLevel);
break; break;
case gl::Texture::DIRTY_BIT_USAGE: case gl::Texture::DIRTY_BIT_USAGE:
break; break;
...@@ -925,8 +986,8 @@ void TextureGL::setMinFilter(GLenum filter) ...@@ -925,8 +986,8 @@ void TextureGL::setMinFilter(GLenum filter)
mAppliedSampler.minFilter = filter; mAppliedSampler.minFilter = filter;
mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_MIN_FILTER); mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_MIN_FILTER);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MIN_FILTER, filter); mFunctions->texParameteri(getTarget(), GL_TEXTURE_MIN_FILTER, filter);
} }
} }
void TextureGL::setMagFilter(GLenum filter) void TextureGL::setMagFilter(GLenum filter)
...@@ -936,8 +997,8 @@ void TextureGL::setMagFilter(GLenum filter) ...@@ -936,8 +997,8 @@ void TextureGL::setMagFilter(GLenum filter)
mAppliedSampler.magFilter = filter; mAppliedSampler.magFilter = filter;
mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_MAG_FILTER); mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_MAG_FILTER);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
mFunctions->texParameteri(mState.mTarget, GL_TEXTURE_MAG_FILTER, filter); mFunctions->texParameteri(getTarget(), GL_TEXTURE_MAG_FILTER, filter);
} }
} }
...@@ -954,8 +1015,8 @@ void TextureGL::setSwizzle(GLint swizzle[4]) ...@@ -954,8 +1015,8 @@ void TextureGL::setSwizzle(GLint swizzle[4])
mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_SWIZZLE_BLUE); mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_SWIZZLE_BLUE);
mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_SWIZZLE_ALPHA); mLocalDirtyBits.set(gl::Texture::DIRTY_BIT_SWIZZLE_ALPHA);
mStateManager->bindTexture(mState.mTarget, mTextureID); mStateManager->bindTexture(getTarget(), mTextureID);
mFunctions->texParameteriv(mState.mTarget, GL_TEXTURE_SWIZZLE_RGBA, swizzle); mFunctions->texParameteriv(getTarget(), GL_TEXTURE_SWIZZLE_RGBA, swizzle);
} }
} }
...@@ -1071,7 +1132,7 @@ void TextureGL::syncTextureStateSwizzle(const FunctionsGL *functions, ...@@ -1071,7 +1132,7 @@ void TextureGL::syncTextureStateSwizzle(const FunctionsGL *functions,
} }
*outValue = resultSwizzle; *outValue = resultSwizzle;
functions->texParameteri(mState.mTarget, name, resultSwizzle); functions->texParameteri(getTarget(), name, resultSwizzle);
} }
void TextureGL::setLevelInfo(size_t level, size_t levelCount, const LevelInfoGL &levelInfo) void TextureGL::setLevelInfo(size_t level, size_t levelCount, const LevelInfoGL &levelInfo)
...@@ -1097,4 +1158,8 @@ GLuint TextureGL::getTextureID() const ...@@ -1097,4 +1158,8 @@ GLuint TextureGL::getTextureID() const
return mTextureID; return mTextureID;
} }
GLenum TextureGL::getTarget() const
{
return mState.mTarget;
}
} }
src/libANGLE/renderer/gl/TextureGL.h
...@@ -74,6 +74,26 @@ class TextureGL : public TextureImpl ...@@ -74,6 +74,26 @@ class TextureGL : public TextureImpl
gl::Error copySubImage(GLenum target, size_t level, const gl::Offset &destOffset, const gl::Rectangle &sourceArea, gl::Error copySubImage(GLenum target, size_t level, const gl::Offset &destOffset, const gl::Rectangle &sourceArea,
const gl::Framebuffer *source) override; const gl::Framebuffer *source) override;
gl::Error copyTexture(GLenum internalFormat,
GLenum type,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
const gl::Texture *source) override;
gl::Error copySubTexture(const gl::Offset &destOffset,
const gl::Rectangle &sourceArea,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
const gl::Texture *source) override;
gl::Error copySubTextureHelper(const gl::Offset &destOffset,
const gl::Rectangle &sourceArea,
GLenum destFormat,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
const gl::Texture *source);
gl::Error setStorage(GLenum target, size_t levels, GLenum internalFormat, const gl::Extents &size) override; gl::Error setStorage(GLenum target, size_t levels, GLenum internalFormat, const gl::Extents &size) override;
gl::Error setImageExternal(GLenum target, gl::Error setImageExternal(GLenum target,
...@@ -88,6 +108,7 @@ class TextureGL : public TextureImpl ...@@ -88,6 +108,7 @@ class TextureGL : public TextureImpl
gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override; gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
GLuint getTextureID() const; GLuint getTextureID() const;
GLenum getTarget() const;
void setBaseLevel(GLuint) override {} void setBaseLevel(GLuint) override {}
...@@ -107,6 +128,7 @@ class TextureGL : public TextureImpl ...@@ -107,6 +128,7 @@ class TextureGL : public TextureImpl
GLenum format, GLenum format,
GLenum type, GLenum type,
const uint8_t *pixels); const uint8_t *pixels);
// This changes the current pixel unpack state that will have to be reapplied.
void reserveTexImageToBeFilled(GLenum target, void reserveTexImageToBeFilled(GLenum target,
size_t level, size_t level,
GLenum internalFormat, GLenum internalFormat,
......
src/libANGLE/renderer/gl/renderergl_utils.cpp
...@@ -859,6 +859,8 @@ void GenerateCaps(const FunctionsGL *functions, gl::Caps *caps, gl::TextureCapsM ...@@ -859,6 +859,8 @@ void GenerateCaps(const FunctionsGL *functions, gl::Caps *caps, gl::TextureCapsM
functions->hasGLESExtension("GL_KHR_robustness") || functions->hasGLESExtension("GL_KHR_robustness") ||
functions->hasGLESExtension("GL_EXT_robustness"); functions->hasGLESExtension("GL_EXT_robustness");
extensions->copyTexture = true;
// NV_path_rendering // NV_path_rendering
// We also need interface query which is available in // We also need interface query which is available in
// >= 4.3 core or ARB_interface_query or >= GLES 3.1 // >= 4.3 core or ARB_interface_query or >= GLES 3.1
......
src/tests/gl_tests/CopyTextureTest.cpp
...@@ -532,7 +532,7 @@ TEST_P(CopyTextureTest, UnmultiplyAlpha) ...@@ -532,7 +532,7 @@ TEST_P(CopyTextureTest, UnmultiplyAlpha)
} }
// Test that unmultipying and premultiplying the alpha is the same as doing neither // Test that unmultipying and premultiplying the alpha is the same as doing neither
TEST_P(CopyTextureTest, UnmultiplyAndPremultplyAlpha) TEST_P(CopyTextureTest, UnmultiplyAndPremultiplyAlpha)
{ {
if (!checkExtensions()) if (!checkExtensions())
{ {
...@@ -559,6 +559,74 @@ TEST_P(CopyTextureTest, UnmultiplyAndPremultplyAlpha) ...@@ -559,6 +559,74 @@ TEST_P(CopyTextureTest, UnmultiplyAndPremultplyAlpha)
EXPECT_GL_NO_ERROR(); EXPECT_GL_NO_ERROR();
} }
// Test to ensure that CopyTexture works with LUMINANCE_ALPHA texture
TEST_P(CopyTextureTest, LuminanceAlpha)
{
if (!checkExtensions())
{
return;
}
uint8_t originalPixels[] = {163u, 67u};
GLColor expectedPixels(163u, 163u, 163u, 67u);
glBindTexture(GL_TEXTURE_2D, mTextures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 1, 1, 0, GL_LUMINANCE_ALPHA,
GL_UNSIGNED_BYTE, &originalPixels);
glCopyTextureCHROMIUM(mTextures[0], mTextures[1], GL_RGBA, GL_UNSIGNED_BYTE, false, false,
false);
EXPECT_GL_NO_ERROR();
EXPECT_PIXEL_COLOR_EQ(0, 0, expectedPixels);
}
// Test to ensure that CopyTexture works with LUMINANCE texture
TEST_P(CopyTextureTest, Luminance)
{
if (!checkExtensions())
{
return;
}
uint8_t originalPixels[] = {57u};
GLColor expectedPixels(57u, 57u, 57u, 255u);
glBindTexture(GL_TEXTURE_2D, mTextures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
&originalPixels);
glCopyTextureCHROMIUM(mTextures[0], mTextures[1], GL_RGBA, GL_UNSIGNED_BYTE, false, false,
false);
EXPECT_GL_NO_ERROR();
EXPECT_PIXEL_COLOR_EQ(0, 0, expectedPixels);
}
// Test to ensure that CopyTexture works with ALPHA texture
TEST_P(CopyTextureTest, Alpha)
{
if (!checkExtensions())
{
return;
}
uint8_t originalPixels[] = {77u};
GLColor expectedPixels(0u, 0u, 0u, 77u);
glBindTexture(GL_TEXTURE_2D, mTextures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 1, 1, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &originalPixels);
glCopyTextureCHROMIUM(mTextures[0], mTextures[1], GL_RGBA, GL_UNSIGNED_BYTE, false, false,
false);
EXPECT_GL_NO_ERROR();
EXPECT_PIXEL_COLOR_EQ(0, 0, expectedPixels);
}
// Use this to select which configurations (e.g. which renderer, which GLES major version) these // Use this to select which configurations (e.g. which renderer, which GLES major version) these
// tests should be run against. // tests should be run against.
ANGLE_INSTANTIATE_TEST(CopyTextureTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES()); ANGLE_INSTANTIATE_TEST(CopyTextureTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES());
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment