Skip to content

A
angle
Commit 8234e7b3 by Jamie Madill Committed by Commit Bot
Options

Refactor some errors into ANGLE_TRY macros.

BUG=None Change-Id: I00ff2523995cb49d1af60cae62c2bba0d020eed4 Reviewed-on: https://chromium-review.googlesource.com/395569 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org>
parent ef300b15
Showing with 262 additions and 920 deletions
src/libANGLE/renderer/d3d/BufferD3D.cpp
......@@ -179,11 +179,7 @@ gl::Error BufferD3D::getIndexRange(GLenum type,
gl::IndexRange *outRange)
{
const uint8_t *data = nullptr;
gl::Error error = getData(&data);
if (error.isError())
{
return error;
}
ANGLE_TRY(getData(&data));
*outRange = gl::ComputeIndexRange(type, data + offset, count, primitiveRestartEnabled);
return gl::Error(GL_NO_ERROR);
......
src/libANGLE/renderer/d3d/TextureD3D.cpp
......@@ -46,12 +46,7 @@ gl::Error GetUnpackPointer(const gl::PixelUnpackState &unpack, const uint8_t *pi
BufferD3D *bufferD3D = GetImplAs<BufferD3D>(pixelBuffer);
ASSERT(bufferD3D);
const uint8_t *bufferData = NULL;
gl::Error error = bufferD3D->getData(&bufferData);
if (error.isError())
{
return error;
}
ANGLE_TRY(bufferD3D->getData(&bufferData));
*pointerOut = bufferData + offset;
}
else
......@@ -92,25 +87,17 @@ TextureD3D::~TextureD3D()
gl::Error TextureD3D::getNativeTexture(TextureStorage **outStorage)
{
// ensure the underlying texture is created
gl::Error error = initializeStorage(false);
if (error.isError())
{
return error;
}
ANGLE_TRY(initializeStorage(false));
if (mTexStorage)
{
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
}
ASSERT(outStorage);
*outStorage = mTexStorage;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
GLint TextureD3D::getLevelZeroWidth() const
......@@ -195,33 +182,24 @@ gl::Error TextureD3D::setImageImpl(const gl::ImageIndex &index,
// We no longer need the "GLenum format" parameter to TexImage to determine what data format "pixels" contains.
// From our image internal format we know how many channels to expect, and "type" gives the format of pixel's components.
const uint8_t *pixelData = NULL;
gl::Error error = GetUnpackPointer(unpack, pixels, layerOffset, &pixelData);
if (error.isError())
{
return error;
}
ANGLE_TRY(GetUnpackPointer(unpack, pixels, layerOffset, &pixelData));
if (pixelData != nullptr)
{
if (shouldUseSetData(image))
{
error = mTexStorage->setData(index, image, NULL, type, unpack, pixelData);
ANGLE_TRY(mTexStorage->setData(index, image, NULL, type, unpack, pixelData));
}
else
{
gl::Box fullImageArea(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth());
error = image->loadData(fullImageArea, unpack, type, pixelData, index.is3D());
}
if (error.isError())
{
return error;
ANGLE_TRY(image->loadData(fullImageArea, unpack, type, pixelData, index.is3D()));
}
mDirtyImages = true;
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D::subImage(const gl::ImageIndex &index, const gl::Box &area, GLenum format, GLenum type,
......@@ -229,11 +207,7 @@ gl::Error TextureD3D::subImage(const gl::ImageIndex &index, const gl::Box &area,
{
// CPU readback & copy where direct GPU copy is not supported
const uint8_t *pixelData = NULL;
gl::Error error = GetUnpackPointer(unpack, pixels, layerOffset, &pixelData);
if (error.isError())
{
return error;
}
ANGLE_TRY(GetUnpackPointer(unpack, pixels, layerOffset, &pixelData));
if (pixelData != NULL)
{
......@@ -245,18 +219,8 @@ gl::Error TextureD3D::subImage(const gl::ImageIndex &index, const gl::Box &area,
return mTexStorage->setData(index, image, &area, type, unpack, pixelData);
}
error = image->loadData(area, unpack, type, pixelData, index.is3D());
if (error.isError())
{
return error;
}
error = commitRegion(index, area);
if (error.isError())
{
return error;
}
ANGLE_TRY(image->loadData(area, unpack, type, pixelData, index.is3D()));
ANGLE_TRY(commitRegion(index, area));
mDirtyImages = true;
}
......@@ -279,20 +243,12 @@ gl::Error TextureD3D::setCompressedImageImpl(const gl::ImageIndex &index,
// We no longer need the "GLenum format" parameter to TexImage to determine what data format "pixels" contains.
// From our image internal format we know how many channels to expect, and "type" gives the format of pixel's components.
const uint8_t *pixelData = NULL;
gl::Error error = GetUnpackPointer(unpack, pixels, layerOffset, &pixelData);
if (error.isError())
{
return error;
}
ANGLE_TRY(GetUnpackPointer(unpack, pixels, layerOffset, &pixelData));
if (pixelData != NULL)
{
gl::Box fullImageArea(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth());
error = image->loadCompressedData(fullImageArea, pixelData);
if (error.isError())
{
return error;
}
ANGLE_TRY(image->loadCompressedData(fullImageArea, pixelData));
mDirtyImages = true;
}
......@@ -305,22 +261,14 @@ gl::Error TextureD3D::subImageCompressed(const gl::ImageIndex &index, const gl::
ptrdiff_t layerOffset)
{
const uint8_t *pixelData = NULL;
gl::Error error = GetUnpackPointer(unpack, pixels, layerOffset, &pixelData);
if (error.isError())
{
return error;
}
ANGLE_TRY(GetUnpackPointer(unpack, pixels, layerOffset, &pixelData));
if (pixelData != NULL)
{
ImageD3D *image = getImage(index);
ASSERT(image);
error = image->loadCompressedData(area, pixelData);
if (error.isError())
{
return error;
}
ANGLE_TRY(image->loadCompressedData(area, pixelData));
mDirtyImages = true;
}
......@@ -357,13 +305,11 @@ gl::Error TextureD3D::fastUnpackPixels(const gl::PixelUnpackState &unpack, const
uintptr_t offset = reinterpret_cast<uintptr_t>(pixels);
gl::Error error = mRenderer->fastCopyBufferToTexture(unpack, static_cast<unsigned int>(offset), destRenderTarget, sizedInternalFormat, type, destArea);
if (error.isError())
{
return error;
}
ANGLE_TRY(mRenderer->fastCopyBufferToTexture(unpack, static_cast<unsigned int>(offset),
destRenderTarget, sizedInternalFormat, type,
destArea));
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
GLint TextureD3D::creationLevels(GLsizei width, GLsizei height, GLsizei depth) const
......@@ -416,17 +362,8 @@ gl::Error TextureD3D::generateMipmap()
{
// Switch to using the mipmapped texture.
TextureStorage *textureStorage = NULL;
gl::Error error = getNativeTexture(&textureStorage);
if (error.isError())
{
return error;
}
error = textureStorage->useLevelZeroWorkaroundTexture(false);
if (error.isError())
{
return error;
}
ANGLE_TRY(getNativeTexture(&textureStorage));
ANGLE_TRY(textureStorage->useLevelZeroWorkaroundTexture(false));
}
// Set up proper mipmap chain in our Image array.
......@@ -434,27 +371,15 @@ gl::Error TextureD3D::generateMipmap()
if (mTexStorage && mTexStorage->supportsNativeMipmapFunction())
{
gl::Error error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
// Generate the mipmap chain using the ad-hoc DirectX function.
error = mRenderer->generateMipmapUsingD3D(mTexStorage, mState);
if (error.isError())
{
return error;
}
ANGLE_TRY(mRenderer->generateMipmapUsingD3D(mTexStorage, mState));
}
else
{
// Generate the mipmap chain, one level at a time.
gl::Error error = generateMipmapUsingImages(maxLevel);
if (error.isError())
{
return error;
}
ANGLE_TRY(generateMipmapUsingImages(maxLevel));
}
return gl::Error(GL_NO_ERROR);
......@@ -478,20 +403,12 @@ gl::Error TextureD3D::generateMipmapUsingImages(const GLuint maxLevel)
gl::ImageIndex srcIndex = getImageIndex(mBaseLevel, layer);
ImageD3D *image = getImage(srcIndex);
gl::Error error = image->copyFromTexStorage(srcIndex, mTexStorage);
if (error.isError())
{
return error;
}
ANGLE_TRY(image->copyFromTexStorage(srcIndex, mTexStorage));
}
}
else
{
gl::Error error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
}
}
......@@ -514,20 +431,12 @@ gl::Error TextureD3D::generateMipmapUsingImages(const GLuint maxLevel)
if (renderableStorage)
{
// GPU-side mipmapping
gl::Error error = mTexStorage->generateMipmap(sourceIndex, destIndex);
if (error.isError())
{
return error;
}
ANGLE_TRY(mTexStorage->generateMipmap(sourceIndex, destIndex));
}
else
{
// CPU-side mipmapping
gl::Error error = mRenderer->generateMipmap(getImage(destIndex), getImage(sourceIndex));
if (error.isError())
{
return error;
}
ANGLE_TRY(mRenderer->generateMipmap(getImage(destIndex), getImage(sourceIndex)));
}
}
}
......@@ -537,7 +446,7 @@ gl::Error TextureD3D::generateMipmapUsingImages(const GLuint maxLevel)
updateStorage();
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool TextureD3D::isBaseImageZeroSize() const
......@@ -569,11 +478,7 @@ bool TextureD3D::isBaseImageZeroSize() const
gl::Error TextureD3D::ensureRenderTarget()
{
gl::Error error = initializeStorage(true);
if (error.isError())
{
return error;
}
ANGLE_TRY(initializeStorage(true));
if (!isBaseImageZeroSize())
{
......@@ -581,13 +486,9 @@ gl::Error TextureD3D::ensureRenderTarget()
if (!mTexStorage->isRenderTarget())
{
TextureStorage *newRenderTargetStorage = NULL;
error = createCompleteStorage(true, &newRenderTargetStorage);
if (error.isError())
{
return error;
}
ANGLE_TRY(createCompleteStorage(true, &newRenderTargetStorage));
error = mTexStorage->copyToStorage(newRenderTargetStorage);
gl::Error error = mTexStorage->copyToStorage(newRenderTargetStorage);
if (error.isError())
{
SafeDelete(newRenderTargetStorage);
......@@ -603,7 +504,7 @@ gl::Error TextureD3D::ensureRenderTarget()
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool TextureD3D::canCreateRenderTargetForImage(const gl::ImageIndex &index) const
......@@ -619,16 +520,11 @@ gl::Error TextureD3D::commitRegion(const gl::ImageIndex &index, const gl::Box &r
{
ASSERT(isValidIndex(index));
ImageD3D *image = getImage(index);
gl::Error error = image->copyToStorage(mTexStorage, index, region);
if (error.isError())
{
return error;
}
ANGLE_TRY(image->copyToStorage(mTexStorage, index, region));
image->markClean();
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
......@@ -784,7 +680,7 @@ gl::Error TextureD3D_2D::setImage(GLenum target,
ANGLE_TRY(setImageImpl(index, type, unpack, pixels, 0));
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2D::setSubImage(GLenum target,
......@@ -1022,16 +918,11 @@ gl::Error TextureD3D_2D::setStorage(GLenum target, size_t levels, GLenum interna
return error;
}
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
mImmutable = true;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureD3D_2D::bindTexImage(egl::Surface *surface)
......@@ -1116,17 +1007,8 @@ gl::Error TextureD3D_2D::getRenderTarget(const gl::ImageIndex &index, RenderTarg
ASSERT(!index.hasLayer());
// ensure the underlying texture is created
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
error = updateStorageLevel(index.mipIndex);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
ANGLE_TRY(updateStorageLevel(index.mipIndex));
return mTexStorage->getRenderTarget(index, outRT);
}
......@@ -1201,13 +1083,9 @@ gl::Error TextureD3D_2D::initializeStorage(bool renderTarget)
bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
TextureStorage *storage = NULL;
gl::Error error = createCompleteStorage(createRenderTarget, &storage);
if (error.isError())
{
return error;
}
ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
error = setCompleteTexStorage(storage);
gl::Error error = setCompleteTexStorage(storage);
if (error.isError())
{
SafeDelete(storage);
......@@ -1217,11 +1095,7 @@ gl::Error TextureD3D_2D::initializeStorage(bool renderTarget)
ASSERT(mTexStorage);
// flush image data to the storage
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
return gl::Error(GL_NO_ERROR);
}
......@@ -1261,11 +1135,7 @@ gl::Error TextureD3D_2D::setCompleteTexStorage(TextureStorage *newCompleteTexSto
{
for (int level = 0; level < newCompleteTexStorage->getLevelCount(); level++)
{
gl::Error error = mImageArray[level]->setManagedSurface2D(newCompleteTexStorage, level);
if (error.isError())
{
return error;
}
ANGLE_TRY(mImageArray[level]->setManagedSurface2D(newCompleteTexStorage, level));
}
}
......@@ -1274,7 +1144,7 @@ gl::Error TextureD3D_2D::setCompleteTexStorage(TextureStorage *newCompleteTexSto
mDirtyImages = true;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2D::updateStorage()
......@@ -1285,15 +1155,11 @@ gl::Error TextureD3D_2D::updateStorage()
{
if (mImageArray[level]->isDirty() && isLevelComplete(level))
{
gl::Error error = updateStorageLevel(level);
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorageLevel(level));
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2D::updateStorageLevel(int level)
......@@ -1305,14 +1171,10 @@ gl::Error TextureD3D_2D::updateStorageLevel(int level)
{
gl::ImageIndex index = gl::ImageIndex::Make2D(level);
gl::Box region(0, 0, 0, getWidth(level), getHeight(level), 1);
gl::Error error = commitRegion(index, region);
if (error.isError())
{
return error;
}
ANGLE_TRY(commitRegion(index, region));
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureD3D_2D::redefineImage(size_t level,
......@@ -1491,12 +1353,7 @@ gl::Error TextureD3D_Cube::setCompressedSubImage(GLenum target, size_t level, co
gl::ImageIndex index = gl::ImageIndex::MakeCube(target, static_cast<GLint>(level));
gl::Error error = TextureD3D::subImageCompressed(index, area, format, unpack, pixels, 0);
if (error.isError())
{
return error;
}
ANGLE_TRY(TextureD3D::subImageCompressed(index, area, format, unpack, pixels, 0));
return commitRegion(index, area);
}
......@@ -1521,34 +1378,21 @@ gl::Error TextureD3D_Cube::copyImage(GLenum target,
// so we should use the non-rendering copy path.
if (!canCreateRenderTargetForImage(index) || mRenderer->getWorkarounds().zeroMaxLodWorkaround)
{
gl::Error error =
mImageArray[faceIndex][level]->copyFromFramebuffer(destOffset, sourceArea, source);
if (error.isError())
{
return error;
}
ANGLE_TRY(
mImageArray[faceIndex][level]->copyFromFramebuffer(destOffset, sourceArea, source));
mDirtyImages = true;
}
else
{
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
mImageArray[faceIndex][level]->markClean();
ASSERT(size.width == size.height);
if (size.width > 0 && isValidFaceLevel(faceIndex, level))
{
error = mRenderer->copyImageCube(source, sourceArea, internalFormat, destOffset, mTexStorage, target, level);
if (error.isError())
{
return error;
}
ANGLE_TRY(mRenderer->copyImageCube(source, sourceArea, internalFormat, destOffset,
mTexStorage, target, level));
}
}
......@@ -1581,26 +1425,13 @@ gl::Error TextureD3D_Cube::copySubImage(GLenum target,
}
else
{
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
if (isValidFaceLevel(faceIndex, level))
{
error = updateStorageFaceLevel(faceIndex, level);
if (error.isError())
{
return error;
}
error = mRenderer->copyImageCube(source, sourceArea, gl::GetInternalFormatInfo(getBaseLevelInternalFormat()).format,
destOffset, mTexStorage, target, level);
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorageFaceLevel(faceIndex, level));
ANGLE_TRY(mRenderer->copyImageCube(
source, sourceArea, gl::GetInternalFormatInfo(getBaseLevelInternalFormat()).format,
destOffset, mTexStorage, target, level));
}
}
......@@ -1642,16 +1473,11 @@ gl::Error TextureD3D_Cube::setStorage(GLenum target, size_t levels, GLenum inter
return error;
}
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
mImmutable = true;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
......@@ -1714,17 +1540,8 @@ gl::Error TextureD3D_Cube::getRenderTarget(const gl::ImageIndex &index, RenderTa
ASSERT(gl::IsCubeMapTextureTarget(index.type));
// ensure the underlying texture is created
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
error = updateStorageFaceLevel(index.layerIndex, index.mipIndex);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
ANGLE_TRY(updateStorageFaceLevel(index.layerIndex, index.mipIndex));
return mTexStorage->getRenderTarget(index, outRT);
}
......@@ -1734,25 +1551,21 @@ gl::Error TextureD3D_Cube::initializeStorage(bool renderTarget)
// Only initialize the first time this texture is used as a render target or shader resource
if (mTexStorage)
{
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
// do not attempt to create storage for nonexistant data
if (!isFaceLevelComplete(0, getBaseLevel()))
{
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
TextureStorage *storage = NULL;
gl::Error error = createCompleteStorage(createRenderTarget, &storage);
if (error.isError())
{
return error;
}
ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
error = setCompleteTexStorage(storage);
gl::Error error = setCompleteTexStorage(storage);
if (error.isError())
{
SafeDelete(storage);
......@@ -1762,13 +1575,9 @@ gl::Error TextureD3D_Cube::initializeStorage(bool renderTarget)
ASSERT(mTexStorage);
// flush image data to the storage
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_Cube::createCompleteStorage(bool renderTarget, TextureStorage **outTexStorage) const
......@@ -1809,11 +1618,8 @@ gl::Error TextureD3D_Cube::setCompleteTexStorage(TextureStorage *newCompleteTexS
{
for (int level = 0; level < newCompleteTexStorage->getLevelCount(); level++)
{
gl::Error error = mImageArray[faceIndex][level]->setManagedSurfaceCube(newCompleteTexStorage, faceIndex, level);
if (error.isError())
{
return error;
}
ANGLE_TRY(mImageArray[faceIndex][level]->setManagedSurfaceCube(
newCompleteTexStorage, faceIndex, level));
}
}
}
......@@ -1835,16 +1641,12 @@ gl::Error TextureD3D_Cube::updateStorage()
{
if (mImageArray[face][level]->isDirty() && isFaceLevelComplete(face, level))
{
gl::Error error = updateStorageFaceLevel(face, level);
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorageFaceLevel(face, level));
}
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool TextureD3D_Cube::isValidFaceLevel(int faceIndex, int level) const
......@@ -1912,14 +1714,10 @@ gl::Error TextureD3D_Cube::updateStorageFaceLevel(int faceIndex, int level)
GLenum faceTarget = gl::LayerIndexToCubeMapTextureTarget(faceIndex);
gl::ImageIndex index = gl::ImageIndex::MakeCube(faceTarget, level);
gl::Box region(0, 0, 0, image->getWidth(), image->getHeight(), 1);
gl::Error error = commitRegion(index, region);
if (error.isError())
{
return error;
}
ANGLE_TRY(commitRegion(index, region));
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureD3D_Cube::redefineImage(int faceIndex, GLint level, GLenum internalformat, const gl::Extents &size)
......@@ -2085,19 +1883,12 @@ gl::Error TextureD3D_3D::setImage(GLenum target,
{
// Will try to create RT storage if it does not exist
RenderTargetD3D *destRenderTarget = NULL;
gl::Error error = getRenderTarget(index, &destRenderTarget);
if (error.isError())
{
return error;
}
ANGLE_TRY(getRenderTarget(index, &destRenderTarget));
gl::Box destArea(0, 0, 0, getWidth(level), getHeight(level), getDepth(level));
error = fastUnpackPixels(unpack, pixels, destArea, sizedInternalFormat, type, destRenderTarget);
if (error.isError())
{
return error;
}
ANGLE_TRY(fastUnpackPixels(unpack, pixels, destArea, sizedInternalFormat, type,
destRenderTarget));
// Ensure we don't overwrite our newly initialized data
mImageArray[level]->markClean();
......@@ -2107,11 +1898,7 @@ gl::Error TextureD3D_3D::setImage(GLenum target,
if (!fastUnpacked)
{
gl::Error error = setImageImpl(index, type, unpack, pixels, 0);
if (error.isError())
{
return error;
}
ANGLE_TRY(setImageImpl(index, type, unpack, pixels, 0));
}
return gl::Error(GL_NO_ERROR);
......@@ -2134,12 +1921,7 @@ gl::Error TextureD3D_3D::setSubImage(GLenum target,
if (isFastUnpackable(unpack, getInternalFormat(level)) && isLevelComplete(level))
{
RenderTargetD3D *destRenderTarget = NULL;
gl::Error error = getRenderTarget(index, &destRenderTarget);
if (error.isError())
{
return error;
}
ANGLE_TRY(getRenderTarget(index, &destRenderTarget));
ASSERT(!mImageArray[level]->isDirty());
return fastUnpackPixels(unpack, pixels, area, getInternalFormat(level), type, destRenderTarget);
......@@ -2174,12 +1956,7 @@ gl::Error TextureD3D_3D::setCompressedSubImage(GLenum target, size_t level, cons
ASSERT(target == GL_TEXTURE_3D);
gl::ImageIndex index = gl::ImageIndex::Make3D(static_cast<GLint>(level));
gl::Error error = TextureD3D::subImageCompressed(index, area, format, unpack, pixels, 0);
if (error.isError())
{
return error;
}
ANGLE_TRY(TextureD3D::subImageCompressed(index, area, format, unpack, pixels, 0));
return commitRegion(index, area);
}
......@@ -2203,37 +1980,18 @@ gl::Error TextureD3D_3D::copySubImage(GLenum target,
if (canCreateRenderTargetForImage(index))
{
gl::Error error = mImageArray[level]->copyFromFramebuffer(destOffset, sourceArea, source);
if (error.isError())
{
return error;
}
ANGLE_TRY(mImageArray[level]->copyFromFramebuffer(destOffset, sourceArea, source));
mDirtyImages = true;
}
else
{
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
if (isValidLevel(level))
{
error = updateStorageLevel(level);
if (error.isError())
{
return error;
}
error = mRenderer->copyImage3D(source, sourceArea,
gl::GetInternalFormatInfo(getBaseLevelInternalFormat()).format,
destOffset, mTexStorage, level);
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorageLevel(level));
ANGLE_TRY(mRenderer->copyImage3D(
source, sourceArea, gl::GetInternalFormatInfo(getBaseLevelInternalFormat()).format,
destOffset, mTexStorage, level));
}
}
......@@ -2270,16 +2028,11 @@ gl::Error TextureD3D_3D::setStorage(GLenum target, size_t levels, GLenum interna
return error;
}
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
mImmutable = true;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureD3D_3D::bindTexImage(egl::Surface *surface)
......@@ -2310,27 +2063,15 @@ void TextureD3D_3D::initMipmapImages()
gl::Error TextureD3D_3D::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
{
// ensure the underlying texture is created
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
if (index.hasLayer())
{
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
}
else
{
error = updateStorageLevel(index.mipIndex);
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorageLevel(index.mipIndex));
}
return mTexStorage->getRenderTarget(index, outRT);
......@@ -2353,13 +2094,9 @@ gl::Error TextureD3D_3D::initializeStorage(bool renderTarget)
bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
TextureStorage *storage = NULL;
gl::Error error = createCompleteStorage(createRenderTarget, &storage);
if (error.isError())
{
return error;
}
ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
error = setCompleteTexStorage(storage);
gl::Error error = setCompleteTexStorage(storage);
if (error.isError())
{
SafeDelete(storage);
......@@ -2369,13 +2106,9 @@ gl::Error TextureD3D_3D::initializeStorage(bool renderTarget)
ASSERT(mTexStorage);
// flush image data to the storage
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_3D::createCompleteStorage(bool renderTarget, TextureStorage **outStorage) const
......@@ -2405,7 +2138,7 @@ gl::Error TextureD3D_3D::setCompleteTexStorage(TextureStorage *newCompleteTexSto
// We do not support managed 3D storage, as that is D3D9/ES2-only
ASSERT(!mTexStorage->isManaged());
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_3D::updateStorage()
......@@ -2416,15 +2149,11 @@ gl::Error TextureD3D_3D::updateStorage()
{
if (mImageArray[level]->isDirty() && isLevelComplete(level))
{
gl::Error error = updateStorageLevel(level);
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorageLevel(level));
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool TextureD3D_3D::isValidLevel(int level) const
......@@ -2494,14 +2223,10 @@ gl::Error TextureD3D_3D::updateStorageLevel(int level)
{
gl::ImageIndex index = gl::ImageIndex::Make3D(level);
gl::Box region(0, 0, 0, getWidth(level), getHeight(level), getDepth(level));
gl::Error error = commitRegion(index, region);
if (error.isError())
{
return error;
}
ANGLE_TRY(commitRegion(index, region));
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureD3D_3D::redefineImage(GLint level, GLenum internalformat, const gl::Extents &size)
......@@ -2657,14 +2382,10 @@ gl::Error TextureD3D_2DArray::setImage(GLenum target,
{
const ptrdiff_t layerOffset = (inputDepthPitch * i);
gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, i);
gl::Error error = setImageImpl(index, type, unpack, pixels, layerOffset);
if (error.isError())
{
return error;
}
ANGLE_TRY(setImageImpl(index, type, unpack, pixels, layerOffset));
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2DArray::setSubImage(GLenum target,
......@@ -2691,14 +2412,11 @@ gl::Error TextureD3D_2DArray::setSubImage(GLenum target,
gl::Box layerArea(area.x, area.y, 0, area.width, area.height, 1);
gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, layer);
gl::Error error = TextureD3D::subImage(index, layerArea, format, type, unpack, pixels, layerOffset);
if (error.isError())
{
return error;
}
ANGLE_TRY(
TextureD3D::subImage(index, layerArea, format, type, unpack, pixels, layerOffset));
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2DArray::setCompressedImage(GLenum target,
......@@ -2726,14 +2444,10 @@ gl::Error TextureD3D_2DArray::setCompressedImage(GLenum target,
const ptrdiff_t layerOffset = (inputDepthPitch * i);
gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, i);
gl::Error error = setCompressedImageImpl(index, unpack, pixels, layerOffset);
if (error.isError())
{
return error;
}
ANGLE_TRY(setCompressedImageImpl(index, unpack, pixels, layerOffset));
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2DArray::setCompressedSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format,
......@@ -2755,17 +2469,9 @@ gl::Error TextureD3D_2DArray::setCompressedSubImage(GLenum target, size_t level,
gl::Box layerArea(area.x, area.y, 0, area.width, area.height, 1);
gl::ImageIndex index = gl::ImageIndex::Make2DArray(static_cast<GLint>(level), layer);
gl::Error error = TextureD3D::subImageCompressed(index, layerArea, format, unpack, pixels, layerOffset);
if (error.isError())
{
return error;
}
error = commitRegion(index, layerArea);
if (error.isError())
{
return error;
}
ANGLE_TRY(
TextureD3D::subImageCompressed(index, layerArea, format, unpack, pixels, layerOffset));
ANGLE_TRY(commitRegion(index, layerArea));
}
return gl::Error(GL_NO_ERROR);
......@@ -2792,39 +2498,21 @@ gl::Error TextureD3D_2DArray::copySubImage(GLenum target,
if (canCreateRenderTargetForImage(index))
{
gl::Offset destLayerOffset(destOffset.x, destOffset.y, 0);
gl::Error error = mImageArray[level][destOffset.z]->copyFromFramebuffer(destLayerOffset,
sourceArea, source);
if (error.isError())
{
return error;
}
ANGLE_TRY(mImageArray[level][destOffset.z]->copyFromFramebuffer(destLayerOffset, sourceArea,
source));
mDirtyImages = true;
}
else
{
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
if (isValidLevel(level))
{
error = updateStorageLevel(level);
if (error.isError())
{
return error;
}
error = mRenderer->copyImage2DArray(
ANGLE_TRY(updateStorageLevel(level));
ANGLE_TRY(mRenderer->copyImage2DArray(
source, sourceArea,
gl::GetInternalFormatInfo(getInternalFormat(getBaseLevel())).format, destOffset,
mTexStorage, level);
if (error.isError())
{
return error;
}
mTexStorage, level));
}
}
return gl::Error(GL_NO_ERROR);
......@@ -2870,16 +2558,11 @@ gl::Error TextureD3D_2DArray::setStorage(GLenum target, size_t levels, GLenum in
return error;
}
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
mImmutable = true;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureD3D_2DArray::bindTexImage(egl::Surface *surface)
......@@ -2916,18 +2599,8 @@ void TextureD3D_2DArray::initMipmapImages()
gl::Error TextureD3D_2DArray::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
{
// ensure the underlying texture is created
gl::Error error = ensureRenderTarget();
if (error.isError())
{
return error;
}
error = updateStorageLevel(index.mipIndex);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureRenderTarget());
ANGLE_TRY(updateStorageLevel(index.mipIndex));
return mTexStorage->getRenderTarget(index, outRT);
}
......@@ -2936,25 +2609,21 @@ gl::Error TextureD3D_2DArray::initializeStorage(bool renderTarget)
// Only initialize the first time this texture is used as a render target or shader resource
if (mTexStorage)
{
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
// do not attempt to create storage for nonexistant data
if (!isLevelComplete(getBaseLevel()))
{
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
TextureStorage *storage = NULL;
gl::Error error = createCompleteStorage(createRenderTarget, &storage);
if (error.isError())
{
return error;
}
TextureStorage *storage = nullptr;
ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
error = setCompleteTexStorage(storage);
gl::Error error = setCompleteTexStorage(storage);
if (error.isError())
{
SafeDelete(storage);
......@@ -2964,13 +2633,9 @@ gl::Error TextureD3D_2DArray::initializeStorage(bool renderTarget)
ASSERT(mTexStorage);
// flush image data to the storage
error = updateStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorage());
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2DArray::createCompleteStorage(bool renderTarget, TextureStorage **outStorage) const
......@@ -2988,7 +2653,7 @@ gl::Error TextureD3D_2DArray::createCompleteStorage(bool renderTarget, TextureSt
// TODO(geofflang): Verify storage creation succeeds
*outStorage = mRenderer->createTextureStorage2DArray(internalFormat, renderTarget, width, height, depth, levels);
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2DArray::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
......@@ -3000,7 +2665,7 @@ gl::Error TextureD3D_2DArray::setCompleteTexStorage(TextureStorage *newCompleteT
// We do not support managed 2D array storage, as managed storage is ES2/D3D9 only
ASSERT(!mTexStorage->isManaged());
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureD3D_2DArray::updateStorage()
......@@ -3011,15 +2676,11 @@ gl::Error TextureD3D_2DArray::updateStorage()
{
if (isLevelComplete(level))
{
gl::Error error = updateStorageLevel(level);
if (error.isError())
{
return error;
}
ANGLE_TRY(updateStorageLevel(level));
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool TextureD3D_2DArray::isValidLevel(int level) const
......@@ -3098,11 +2759,7 @@ gl::Error TextureD3D_2DArray::updateStorageLevel(int level)
{
gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, layer);
gl::Box region(0, 0, 0, getWidth(level), getHeight(level), 1);
gl::Error error = commitRegion(index, region);
if (error.isError())
{
return error;
}
ANGLE_TRY(commitRegion(index, region));
}
}
......@@ -3426,4 +3083,4 @@ void TextureD3D_External::markAllImagesDirty()
{
UNREACHABLE();
}
}
} // namespace rx
src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
......@@ -275,11 +275,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
drawBufferStates[colorAttachmentIndex] != GL_NONE)
{
RenderTarget11 *renderTarget = nullptr;
gl::Error error = attachment.getRenderTarget(&renderTarget);
if (error.isError())
{
return error;
}
ANGLE_TRY(attachment.getRenderTarget(&renderTarget));
const gl::InternalFormat &formatInfo = *attachment.getFormat().info;
......@@ -385,11 +381,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
ASSERT(attachment != nullptr);
RenderTarget11 *renderTarget = nullptr;
gl::Error error = attachment->getRenderTarget(&renderTarget);
if (error.isError())
{
return error;
}
ANGLE_TRY(attachment->getRenderTarget(&renderTarget));
const auto &nativeFormat = renderTarget->getFormatSet().format;
......
src/libANGLE/renderer/d3d/d3d11/Fence11.cpp
......@@ -92,11 +92,7 @@ gl::Error FenceNV11::finish()
while (finished != GL_TRUE)
{
loopCount++;
gl::Error error = FenceTestHelper(this, true, &finished);
if (error.isError())
{
return error;
}
ANGLE_TRY(FenceTestHelper(this, true, &finished));
if (loopCount % kDeviceLostCheckPeriod == 0 && mRenderer->testDeviceLost())
{
......@@ -107,7 +103,7 @@ gl::Error FenceNV11::finish()
ScheduleYield();
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
//
......
src/libANGLE/renderer/d3d/d3d11/Image11.cpp
......@@ -50,14 +50,10 @@ gl::Error Image11::generateMipmap(Image11 *dest,
ASSERT(src->getHeight() == 1 || src->getHeight() / 2 == dest->getHeight());
D3D11_MAPPED_SUBRESOURCE destMapped;
gl::Error error = dest->map(D3D11_MAP_WRITE, &destMapped);
if (error.isError())
{
return error;
}
ANGLE_TRY(dest->map(D3D11_MAP_WRITE, &destMapped));
D3D11_MAPPED_SUBRESOURCE srcMapped;
error = src->map(D3D11_MAP_READ, &srcMapped);
gl::Error error = src->map(D3D11_MAP_READ, &srcMapped);
if (error.isError())
{
dest->unmap();
......@@ -78,7 +74,7 @@ gl::Error Image11::generateMipmap(Image11 *dest,
dest->markDirty();
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool Image11::isDirty() const
......@@ -113,26 +109,14 @@ gl::Error Image11::copyToStorage(TextureStorage *storage, const gl::ImageIndex &
if (attemptToReleaseStagingTexture)
{
// If another image is relying on this Storage for its data, then we must let it recover its data before we overwrite it.
gl::Error error = storage11->releaseAssociatedImage(index, this);
if (error.isError())
{
return error;
}
ANGLE_TRY(storage11->releaseAssociatedImage(index, this));
}
ID3D11Resource *stagingTexture = NULL;
unsigned int stagingSubresourceIndex = 0;
gl::Error error = getStagingTexture(&stagingTexture, &stagingSubresourceIndex);
if (error.isError())
{
return error;
}
error = storage11->updateSubresourceLevel(stagingTexture, stagingSubresourceIndex, index, region);
if (error.isError())
{
return error;
}
ANGLE_TRY(getStagingTexture(&stagingTexture, &stagingSubresourceIndex));
ANGLE_TRY(
storage11->updateSubresourceLevel(stagingTexture, stagingSubresourceIndex, index, region));
// Once the image data has been copied into the Storage, we can release it locally.
if (attemptToReleaseStagingTexture)
......@@ -144,7 +128,7 @@ gl::Error Image11::copyToStorage(TextureStorage *storage, const gl::ImageIndex &
mAssociatedImageIndex = index;
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
bool Image11::isAssociatedStorageValid(TextureStorage11* textureStorage) const
......@@ -156,11 +140,7 @@ gl::Error Image11::recoverFromAssociatedStorage()
{
if (mRecoverFromStorage)
{
gl::Error error = createStagingTexture();
if (error.isError())
{
return error;
}
ANGLE_TRY(createStagingTexture());
bool textureStorageCorrect = mAssociatedStorage->isAssociatedImageValid(mAssociatedImageIndex, this);
......@@ -172,12 +152,8 @@ gl::Error Image11::recoverFromAssociatedStorage()
{
// CopySubResource from the Storage to the Staging texture
gl::Box region(0, 0, 0, mWidth, mHeight, mDepth);
error = mAssociatedStorage->copySubresourceLevel(mStagingTexture, mStagingSubresource, mAssociatedImageIndex, region);
if (error.isError())
{
return error;
}
ANGLE_TRY(mAssociatedStorage->copySubresourceLevel(mStagingTexture, mStagingSubresource,
mAssociatedImageIndex, region));
mRecoveredFromStorageCount += 1;
}
......@@ -185,7 +161,7 @@ gl::Error Image11::recoverFromAssociatedStorage()
disassociateStorage();
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void Image11::disassociateStorage()
......@@ -272,11 +248,7 @@ gl::Error Image11::loadData(const gl::Box &area,
LoadImageFunction loadFunction = d3dFormatInfo.loadFunctions(type).loadFunction;
D3D11_MAPPED_SUBRESOURCE mappedImage;
gl::Error error = map(D3D11_MAP_WRITE, &mappedImage);
if (error.isError())
{
return error;
}
ANGLE_TRY(map(D3D11_MAP_WRITE, &mappedImage));
uint8_t *offsetMappedData = (reinterpret_cast<uint8_t*>(mappedImage.pData) + (area.y * mappedImage.RowPitch + area.x * outputPixelSize + area.z * mappedImage.DepthPitch));
loadFunction(area.width, area.height, area.depth,
......@@ -285,7 +257,7 @@ gl::Error Image11::loadData(const gl::Box &area,
unmap();
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input)
......@@ -309,11 +281,7 @@ gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input)
LoadImageFunction loadFunction = d3dFormatInfo.loadFunctions(GL_UNSIGNED_BYTE).loadFunction;
D3D11_MAPPED_SUBRESOURCE mappedImage;
gl::Error error = map(D3D11_MAP_WRITE, &mappedImage);
if (error.isError())
{
return error;
}
ANGLE_TRY(map(D3D11_MAP_WRITE, &mappedImage));
uint8_t* offsetMappedData = reinterpret_cast<uint8_t*>(mappedImage.pData) + ((area.y / outputBlockHeight) * mappedImage.RowPitch +
(area.x / outputBlockWidth) * outputPixelSize +
......@@ -325,7 +293,7 @@ gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input)
unmap();
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Image11::copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureStorage *source)
......@@ -333,11 +301,7 @@ gl::Error Image11::copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureS
TextureStorage11 *storage11 = GetAs<TextureStorage11>(source);
ID3D11Resource *resource = nullptr;
gl::Error error = storage11->getResource(&resource);
if (error.isError())
{
return error;
}
ANGLE_TRY(storage11->getResource(&resource));
UINT subresourceIndex = storage11->getSubresourceIndex(imageIndex);
TextureHelper11 textureHelper =
......@@ -361,11 +325,7 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
if (d3d11Format.texFormat == mDXGIFormat && sourceInternalFormat == mInternalFormat)
{
RenderTargetD3D *renderTarget = nullptr;
gl::Error error = srcAttachment->getRenderTarget(&renderTarget);
if (error.isError())
{
return error;
}
ANGLE_TRY(srcAttachment->getRenderTarget(&renderTarget));
RenderTarget11 *rt11 = GetAs<RenderTarget11>(renderTarget);
ASSERT(rt11->getTexture());
......@@ -381,11 +341,7 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
// This format requires conversion, so we must copy the texture to staging and manually convert
// via readPixels
D3D11_MAPPED_SUBRESOURCE mappedImage;
gl::Error error = map(D3D11_MAP_WRITE, &mappedImage);
if (error.isError())
{
return error;
}
ANGLE_TRY(map(D3D11_MAP_WRITE, &mappedImage));
// determine the offset coordinate into the destination buffer
const auto &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat);
......@@ -400,6 +356,7 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps());
auto loadFunction = destD3D11Format.loadFunctions(destFormatInfo.type);
gl::Error error = gl::NoError();
if (loadFunction.requiresConversion)
{
size_t bufferSize = destFormatInfo.pixelBytes * sourceArea.width * sourceArea.height;
......@@ -436,11 +393,7 @@ gl::Error Image11::copyWithoutConversion(const gl::Offset &destOffset,
// No conversion needed-- use copyback fastpath
ID3D11Resource *stagingTexture = nullptr;
unsigned int stagingSubresourceIndex = 0;
gl::Error error = getStagingTexture(&stagingTexture, &stagingSubresourceIndex);
if (error.isError())
{
return error;
}
ANGLE_TRY(getStagingTexture(&stagingTexture, &stagingSubresourceIndex));
ID3D11Device *device = mRenderer->getDevice();
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
......@@ -505,20 +458,16 @@ gl::Error Image11::copyWithoutConversion(const gl::Offset &destOffset,
}
mDirty = true;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Image11::getStagingTexture(ID3D11Resource **outStagingTexture, unsigned int *outSubresourceIndex)
{
gl::Error error = createStagingTexture();
if (error.isError())
{
return error;
}
ANGLE_TRY(createStagingTexture());
*outStagingTexture = mStagingTexture;
*outSubresourceIndex = mStagingSubresource;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void Image11::releaseStagingTexture()
......@@ -639,19 +588,11 @@ gl::Error Image11::createStagingTexture()
gl::Error Image11::map(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map)
{
// We must recover from the TextureStorage if necessary, even for D3D11_MAP_WRITE.
gl::Error error = recoverFromAssociatedStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(recoverFromAssociatedStorage());
ID3D11Resource *stagingTexture = NULL;
unsigned int subresourceIndex = 0;
error = getStagingTexture(&stagingTexture, &subresourceIndex);
if (error.isError())
{
return error;
}
ANGLE_TRY(getStagingTexture(&stagingTexture, &subresourceIndex));
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
......
src/libANGLE/renderer/d3d/d3d11/Query11.cpp
......@@ -96,17 +96,11 @@ template <typename T>
gl::Error Query11::getResultBase(T *params)
{
ASSERT(mActiveQuery->query == nullptr);
gl::Error error = flush(true);
if (error.isError())
{
return error;
}
ANGLE_TRY(flush(true));
ASSERT(mPendingQueries.empty());
*params = static_cast<T>(mResultSum);
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Query11::getResult(GLint *params)
......@@ -131,14 +125,10 @@ gl::Error Query11::getResult(GLuint64 *params)
gl::Error Query11::isResultAvailable(bool *available)
{
gl::Error error = flush(false);
if (error.isError())
{
return error;
}
ANGLE_TRY(flush(false));
*available = mPendingQueries.empty();
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Query11::pause()
......@@ -167,11 +157,7 @@ gl::Error Query11::resume()
{
if (mActiveQuery->query == nullptr)
{
gl::Error error = flush(false);
if (error.isError())
{
return error;
}
ANGLE_TRY(flush(false));
GLenum queryType = getType();
D3D11_QUERY d3dQueryType = gl_d3d11::ConvertQueryType(queryType);
......@@ -234,11 +220,7 @@ gl::Error Query11::flush(bool force)
do
{
gl::Error error = testQuery(query);
if (error.isError())
{
return error;
}
ANGLE_TRY(testQuery(query));
if (!query->finished && !force)
{
return gl::Error(GL_NO_ERROR);
......@@ -249,7 +231,7 @@ gl::Error Query11::flush(bool force)
mPendingQueries.pop_front();
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Query11::testQuery(QueryState *queryState)
......@@ -408,7 +390,7 @@ gl::Error Query11::testQuery(QueryState *queryState)
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
}
} // namespace rx
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -551,11 +551,7 @@ egl::Error Renderer11::initialize()
{
HRESULT result = S_OK;
egl::Error error = initializeD3DDevice();
if (error.isError())
{
return error;
}
ANGLE_TRY(initializeD3DDevice());
#if !defined(ANGLE_ENABLE_WINDOWS_STORE)
#if !ANGLE_SKIP_DXGI_1_2_CHECK
......@@ -777,11 +773,7 @@ egl::Error Renderer11::initializeD3DDevice()
{
// We should use the inputted D3D11 device instead
void *device = nullptr;
egl::Error error = mEGLDevice->getDevice(&device);
if (error.isError())
{
return error;
}
ANGLE_TRY(mEGLDevice->getDevice(&device));
ID3D11Device *d3dDevice = reinterpret_cast<ID3D11Device *>(device);
if (FAILED(d3dDevice->GetDeviceRemovedReason()))
......@@ -1212,21 +1204,13 @@ gl::Error Renderer11::generateSwizzle(gl::Texture *texture)
ASSERT(textureD3D);
TextureStorage *texStorage = nullptr;
gl::Error error = textureD3D->getNativeTexture(&texStorage);
if (error.isError())
{
return error;
}
ANGLE_TRY(textureD3D->getNativeTexture(&texStorage));
if (texStorage)
{
TextureStorage11 *storage11 = GetAs<TextureStorage11>(texStorage);
const gl::TextureState &textureState = texture->getTextureState();
error = storage11->generateSwizzles(textureState.getSwizzleState());
if (error.isError())
{
return error;
}
ANGLE_TRY(storage11->generateSwizzles(textureState.getSwizzleState()));
}
}
......@@ -1272,11 +1256,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
TextureStorage *storage = nullptr;
gl::Error error = textureD3D->getNativeTexture(&storage);
if (error.isError())
{
return error;
}
ANGLE_TRY(textureD3D->getNativeTexture(&storage));
// Storage should exist, texture should be complete
ASSERT(storage);
......@@ -1294,11 +1274,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
memcmp(&samplerState, &mCurPixelSamplerStates[index], sizeof(gl::SamplerState)) != 0)
{
ID3D11SamplerState *dxSamplerState = NULL;
error = mStateCache.getSamplerState(samplerState, &dxSamplerState);
if (error.isError())
{
return error;
}
ANGLE_TRY(mStateCache.getSamplerState(samplerState, &dxSamplerState));
ASSERT(dxSamplerState != NULL);
mDeviceContext->PSSetSamplers(index, 1, &dxSamplerState);
......@@ -1318,11 +1294,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
memcmp(&samplerState, &mCurVertexSamplerStates[index], sizeof(gl::SamplerState)) != 0)
{
ID3D11SamplerState *dxSamplerState = NULL;
error = mStateCache.getSamplerState(samplerState, &dxSamplerState);
if (error.isError())
{
return error;
}
ANGLE_TRY(mStateCache.getSamplerState(samplerState, &dxSamplerState));
ASSERT(dxSamplerState != NULL);
mDeviceContext->VSSetSamplers(index, 1, &dxSamplerState);
......@@ -1339,7 +1311,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
ASSERT(metadata != nullptr);
metadata->update(index, *texture);
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *texture)
......@@ -1351,11 +1323,7 @@ gl::Error Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *t
TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
TextureStorage *texStorage = nullptr;
gl::Error error = textureImpl->getNativeTexture(&texStorage);
if (error.isError())
{
return error;
}
ANGLE_TRY(textureImpl->getNativeTexture(&texStorage));
// Texture should be complete and have a storage
ASSERT(texStorage);
......@@ -1600,18 +1568,10 @@ gl::Error Renderer11::applyVertexBuffer(const gl::State &state,
const auto &vertexArray = state.getVertexArray();
auto *vertexArray11 = GetImplAs<VertexArray11>(vertexArray);
gl::Error error = vertexArray11->updateDirtyAndDynamicAttribs(mVertexDataManager, state, first,
count, instances);
if (error.isError())
{
return error;
}
ANGLE_TRY(vertexArray11->updateDirtyAndDynamicAttribs(mVertexDataManager, state, first, count,
instances));
error = mStateManager.updateCurrentValueAttribs(state, mVertexDataManager);
if (error.isError())
{
return error;
}
ANGLE_TRY(mStateManager.updateCurrentValueAttribs(state, mVertexDataManager));
// If index information is passed, mark it with the current changed status.
if (indexInfo)
......@@ -1745,12 +1705,8 @@ gl::Error Renderer11::drawArraysImpl(const gl::ContextState &data,
}
rx::ShaderExecutableD3D *pixelExe = nullptr;
gl::Error error =
programD3D->getPixelExecutableForFramebuffer(glState.getDrawFramebuffer(), &pixelExe);
if (error.isError())
{
return error;
}
ANGLE_TRY(
programD3D->getPixelExecutableForFramebuffer(glState.getDrawFramebuffer(), &pixelExe));
// Skip the draw call if rasterizer discard is enabled (or no fragment shader).
if (!pixelExe || glState.getRasterizerState().rasterizerDiscard)
......@@ -1764,12 +1720,8 @@ gl::Error Renderer11::drawArraysImpl(const gl::ContextState &data,
// Retrieve the geometry shader.
rx::ShaderExecutableD3D *geometryExe = nullptr;
error =
programD3D->getGeometryExecutableForPrimitiveType(data, mode, &geometryExe, nullptr);
if (error.isError())
{
return error;
}
ANGLE_TRY(
programD3D->getGeometryExecutableForPrimitiveType(data, mode, &geometryExe, nullptr));
ID3D11GeometryShader *geometryShader =
(geometryExe ? GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : NULL);
......@@ -1931,11 +1883,7 @@ gl::Error Renderer11::drawLineLoop(const gl::ContextState &data,
intptr_t offset = reinterpret_cast<intptr_t>(indices);
const uint8_t *bufferData = NULL;
gl::Error error = storage->getData(&bufferData);
if (error.isError())
{
return error;
}
ANGLE_TRY(storage->getData(&bufferData));
indices = bufferData + offset;
}
......@@ -1964,29 +1912,17 @@ gl::Error Renderer11::drawLineLoop(const gl::ContextState &data,
unsigned int spaceNeeded =
static_cast<unsigned int>(sizeof(GLuint) * mScratchIndexDataBuffer.size());
gl::Error error = mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT);
if (error.isError())
{
return error;
}
ANGLE_TRY(mLineLoopIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT));
void* mappedMemory = NULL;
unsigned int offset;
error = mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset);
if (error.isError())
{
return error;
}
ANGLE_TRY(mLineLoopIB->mapBuffer(spaceNeeded, &mappedMemory, &offset));
// Copy over the converted index data.
memcpy(mappedMemory, &mScratchIndexDataBuffer[0],
sizeof(GLuint) * mScratchIndexDataBuffer.size());
error = mLineLoopIB->unmapBuffer();
if (error.isError())
{
return error;
}
ANGLE_TRY(mLineLoopIB->unmapBuffer());
IndexBuffer11 *indexBuffer = GetAs<IndexBuffer11>(mLineLoopIB->getIndexBuffer());
ID3D11Buffer *d3dIndexBuffer = indexBuffer->getBuffer();
......@@ -2013,7 +1949,7 @@ gl::Error Renderer11::drawLineLoop(const gl::ContextState &data,
mDeviceContext->DrawIndexed(indexCount, 0, baseVertexLocation);
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
......@@ -2035,11 +1971,7 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
intptr_t offset = reinterpret_cast<intptr_t>(indices);
const uint8_t *bufferData = NULL;
gl::Error error = storage->getData(&bufferData);
if (error.isError())
{
return error;
}
ANGLE_TRY(storage->getData(&bufferData));
indexPointer = bufferData + offset;
}
......@@ -2070,27 +2002,15 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
const unsigned int spaceNeeded =
static_cast<unsigned int>(mScratchIndexDataBuffer.size() * sizeof(unsigned int));
gl::Error error = mTriangleFanIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT);
if (error.isError())
{
return error;
}
ANGLE_TRY(mTriangleFanIB->reserveBufferSpace(spaceNeeded, GL_UNSIGNED_INT));
void *mappedMemory = nullptr;
unsigned int offset;
error = mTriangleFanIB->mapBuffer(spaceNeeded, &mappedMemory, &offset);
if (error.isError())
{
return error;
}
ANGLE_TRY(mTriangleFanIB->mapBuffer(spaceNeeded, &mappedMemory, &offset));
memcpy(mappedMemory, &mScratchIndexDataBuffer[0], spaceNeeded);
error = mTriangleFanIB->unmapBuffer();
if (error.isError())
{
return error;
}
ANGLE_TRY(mTriangleFanIB->unmapBuffer());
IndexBuffer11 *indexBuffer = GetAs<IndexBuffer11>(mTriangleFanIB->getIndexBuffer());
ID3D11Buffer *d3dIndexBuffer = indexBuffer->getBuffer();
......@@ -2116,7 +2036,7 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
mDeviceContext->DrawIndexed(indexCount, 0, -minIndex);
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error Renderer11::applyShaders(const gl::ContextState &data, GLenum drawMode)
......@@ -3313,12 +3233,8 @@ gl::Error Renderer11::createRenderTargetCopy(RenderTargetD3D *source, RenderTarg
ASSERT(source != nullptr);
RenderTargetD3D *newRT = nullptr;
gl::Error error = createRenderTarget(source->getWidth(), source->getHeight(),
source->getInternalFormat(), source->getSamples(), &newRT);
if (error.isError())
{
return error;
}
ANGLE_TRY(createRenderTarget(source->getWidth(), source->getHeight(),
source->getInternalFormat(), source->getSamples(), &newRT));
RenderTarget11 *source11 = GetAs<RenderTarget11>(source);
RenderTarget11 *dest11 = GetAs<RenderTarget11>(newRT);
......@@ -3480,11 +3396,8 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
ID3DBlob *binary = NULL;
std::string debugInfo;
gl::Error error = mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, loopMacros, &binary, &debugInfo);
if (error.isError())
{
return error;
}
ANGLE_TRY(mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, loopMacros, &binary,
&debugInfo));
// It's possible that binary is NULL if the compiler failed in all configurations. Set the executable to NULL
// and return GL_NO_ERROR to signify that there was a link error but the internal state is still OK.
......@@ -3494,8 +3407,8 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
return gl::Error(GL_NO_ERROR);
}
error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
streamOutVaryings, separatedOutputBuffers, outExectuable);
gl::Error error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
streamOutVaryings, separatedOutputBuffers, outExectuable);
SafeRelease(binary);
if (error.isError())
......@@ -3508,7 +3421,7 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
(*outExectuable)->appendDebugInfo(debugInfo);
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
UniformStorageD3D *Renderer11::createUniformStorage(size_t storageSize)
......
src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
......@@ -776,6 +776,7 @@ TextureStorage11_2D::~TextureStorage11_2D()
if (error.isError())
{
// TODO: Find a way to report this back to the context
ERR("Error initialization texture storage: %x", error.getCode());
}
}
}
......@@ -969,11 +970,7 @@ gl::Error TextureStorage11_2D::releaseAssociatedImage(const gl::ImageIndex &inde
{
// Force the image to recover from storage before its data is overwritten.
// This will reset mAssociatedImages[level] to nullptr too.
gl::Error error = mAssociatedImages[level]->recoverFromAssociatedStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage());
}
}
}
......@@ -1284,11 +1281,7 @@ gl::Error TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel, ID3D11Render
if (!mSwizzleRenderTargets[mipLevel])
{
ID3D11Resource *swizzleTexture = nullptr;
gl::Error error = getSwizzleTexture(&swizzleTexture);
if (error.isError())
{
return error;
}
ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
ID3D11Device *device = mRenderer->getDevice();
......@@ -1555,11 +1548,7 @@ gl::Error TextureStorage11_EGLImage::getRenderTarget(const gl::ImageIndex &index
ASSERT(index.mipIndex == 0);
UNUSED_ASSERTION_VARIABLE(index);
gl::Error error = checkForUpdatedRenderTarget();
if (error.isError())
{
return error;
}
ANGLE_TRY(checkForUpdatedRenderTarget());
return mImage->getRenderTarget(outRT);
}
......@@ -1567,27 +1556,19 @@ gl::Error TextureStorage11_EGLImage::getRenderTarget(const gl::ImageIndex &index
gl::Error TextureStorage11_EGLImage::copyToStorage(TextureStorage *destStorage)
{
ID3D11Resource *sourceResouce = nullptr;
gl::Error error = getResource(&sourceResouce);
if (error.isError())
{
return error;
}
ANGLE_TRY(getResource(&sourceResouce));
ASSERT(destStorage);
TextureStorage11_2D *dest11 = GetAs<TextureStorage11_2D>(destStorage);
ID3D11Resource *destResource = nullptr;
error = dest11->getResource(&destResource);
if (error.isError())
{
return error;
}
ANGLE_TRY(dest11->getResource(&destResource));
ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext();
immediateContext->CopyResource(destResource, sourceResouce);
dest11->markDirty();
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureStorage11_EGLImage::associateImage(Image11 *, const gl::ImageIndex &)
......@@ -1660,11 +1641,7 @@ gl::Error TextureStorage11_EGLImage::getSwizzleRenderTarget(int mipLevel,
if (!mSwizzleRenderTargets[mipLevel])
{
ID3D11Resource *swizzleTexture = nullptr;
gl::Error error = getSwizzleTexture(&swizzleTexture);
if (error.isError())
{
return error;
}
ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
ID3D11Device *device = mRenderer->getDevice();
......@@ -1686,7 +1663,7 @@ gl::Error TextureStorage11_EGLImage::getSwizzleRenderTarget(int mipLevel,
}
*outRTV = mSwizzleRenderTargets[mipLevel];
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_EGLImage::checkForUpdatedRenderTarget()
......@@ -1739,11 +1716,7 @@ gl::Error TextureStorage11_EGLImage::createSRV(int baseLevel,
else
{
RenderTarget11 *renderTarget = nullptr;
gl::Error error = getImageRenderTarget(&renderTarget);
if (error.isError())
{
return error;
}
ANGLE_TRY(getImageRenderTarget(&renderTarget));
ASSERT(texture == renderTarget->getTexture());
......@@ -1884,36 +1857,20 @@ gl::Error TextureStorage11_Cube::copyToStorage(TextureStorage *destStorage)
// corresponding textures in destStorage.
if (mTexture)
{
gl::Error error = dest11->useLevelZeroWorkaroundTexture(false);
if (error.isError())
{
return error;
}
ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(false));
ID3D11Resource *destResource = nullptr;
error = dest11->getResource(&destResource);
if (error.isError())
{
return error;
}
ANGLE_TRY(dest11->getResource(&destResource));
immediateContext->CopyResource(destResource, mTexture);
}
if (mLevelZeroTexture)
{
gl::Error error = dest11->useLevelZeroWorkaroundTexture(true);
if (error.isError())
{
return error;
}
ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(true));
ID3D11Resource *destResource = nullptr;
error = dest11->getResource(&destResource);
if (error.isError())
{
return error;
}
ANGLE_TRY(dest11->getResource(&destResource));
immediateContext->CopyResource(destResource, mLevelZeroTexture);
}
......@@ -1921,18 +1878,10 @@ gl::Error TextureStorage11_Cube::copyToStorage(TextureStorage *destStorage)
else
{
ID3D11Resource *sourceResouce = nullptr;
gl::Error error = getResource(&sourceResouce);
if (error.isError())
{
return error;
}
ANGLE_TRY(getResource(&sourceResouce));
ID3D11Resource *destResource = nullptr;
error = dest11->getResource(&destResource);
if (error.isError())
{
return error;
}
ANGLE_TRY(dest11->getResource(&destResource));
ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext();
immediateContext->CopyResource(destResource, sourceResouce);
......@@ -1940,7 +1889,7 @@ gl::Error TextureStorage11_Cube::copyToStorage(TextureStorage *destStorage)
dest11->markDirty();
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_Cube::useLevelZeroWorkaroundTexture(bool useLevelZeroTexture)
......@@ -1949,11 +1898,7 @@ gl::Error TextureStorage11_Cube::useLevelZeroWorkaroundTexture(bool useLevelZero
{
if (!mUseLevelZeroTexture && mTexture)
{
gl::Error error = ensureTextureExists(1);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureTextureExists(1));
// Pull data back from the mipped texture if necessary.
ASSERT(mLevelZeroTexture);
......@@ -1972,11 +1917,7 @@ gl::Error TextureStorage11_Cube::useLevelZeroWorkaroundTexture(bool useLevelZero
{
if (mUseLevelZeroTexture && mLevelZeroTexture)
{
gl::Error error = ensureTextureExists(mMipLevels);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureTextureExists(mMipLevels));
// Pull data back from the level zero texture if necessary.
ASSERT(mTexture);
......@@ -1992,7 +1933,7 @@ gl::Error TextureStorage11_Cube::useLevelZeroWorkaroundTexture(bool useLevelZero
mUseLevelZeroTexture = false;
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
void TextureStorage11_Cube::associateImage(Image11 *image, const gl::ImageIndex &index)
......@@ -2085,43 +2026,29 @@ gl::Error TextureStorage11_Cube::releaseAssociatedImage(const gl::ImageIndex &in
{
// Force the image to recover from storage before its data is overwritten.
// This will reset mAssociatedImages[level] to nullptr too.
gl::Error error =
mAssociatedImages[layerTarget][level]->recoverFromAssociatedStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(
mAssociatedImages[layerTarget][level]->recoverFromAssociatedStorage());
}
}
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_Cube::getResource(ID3D11Resource **outResource)
{
if (mUseLevelZeroTexture && mMipLevels > 1)
{
gl::Error error = ensureTextureExists(1);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureTextureExists(1));
*outResource = mLevelZeroTexture;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
else
{
gl::Error error = ensureTextureExists(mMipLevels);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureTextureExists(mMipLevels));
*outResource = mTexture;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
}
......@@ -2130,14 +2057,9 @@ gl::Error TextureStorage11_Cube::getMippedResource(ID3D11Resource **outResource)
// This shouldn't be called unless the zero max LOD workaround is active.
ASSERT(mRenderer->getWorkarounds().zeroMaxLodWorkaround);
gl::Error error = ensureTextureExists(mMipLevels);
if (error.isError())
{
return error;
}
ANGLE_TRY(ensureTextureExists(mMipLevels));
*outResource = mTexture;
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_Cube::ensureTextureExists(int mipLevels)
......@@ -2188,7 +2110,7 @@ gl::Error TextureStorage11_Cube::ensureTextureExists(int mipLevels)
d3d11::SetDebugName(*outputTexture, "TexStorageCube.Texture");
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_Cube::createRenderTargetSRV(ID3D11Resource *texture,
......@@ -2242,11 +2164,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
HRESULT result;
ID3D11Resource *texture = nullptr;
gl::Error error = getResource(&texture);
if (error.isError())
{
return error;
}
ANGLE_TRY(getResource(&texture));
if (mUseLevelZeroTexture)
{
......@@ -2285,15 +2203,12 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
}
ID3D11ShaderResourceView *srv = nullptr;
error = createRenderTargetSRV(texture, index, mFormatInfo.srvFormat, &srv);
if (error.isError())
{
return error;
}
ANGLE_TRY(createRenderTargetSRV(texture, index, mFormatInfo.srvFormat, &srv));
ID3D11ShaderResourceView *blitSRV = nullptr;
if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat)
{
error = createRenderTargetSRV(texture, index, mFormatInfo.blitSRVFormat, &blitSRV);
gl::Error error =
createRenderTargetSRV(texture, index, mFormatInfo.blitSRVFormat, &blitSRV);
if (error.isError())
{
SafeRelease(srv);
......@@ -2501,11 +2416,7 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel,
if (!mSwizzleRenderTargets[mipLevel])
{
ID3D11Resource *swizzleTexture = nullptr;
gl::Error error = getSwizzleTexture(&swizzleTexture);
if (error.isError())
{
return error;
}
ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
ID3D11Device *device = mRenderer->getDevice();
......@@ -2529,7 +2440,7 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel,
}
*outRTV = mSwizzleRenderTargets[mipLevel];
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11::initDropStencilTexture(const gl::ImageIndexIterator &it)
......@@ -2732,16 +2643,12 @@ gl::Error TextureStorage11_3D::releaseAssociatedImage(const gl::ImageIndex &inde
{
// Force the image to recover from storage before its data is overwritten.
// This will reset mAssociatedImages[level] to nullptr too.
gl::Error error = mAssociatedImages[level]->recoverFromAssociatedStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage());
}
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_3D::getResource(ID3D11Resource **outResource)
......@@ -2885,11 +2792,7 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend
HRESULT result;
ID3D11Resource *texture = nullptr;
gl::Error error = getResource(&texture);
if (error.isError())
{
return error;
}
ANGLE_TRY(getResource(&texture));
// TODO, what kind of SRV is expected here?
ID3D11ShaderResourceView *srv = nullptr;
......@@ -2929,7 +2832,7 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend
ASSERT(outRT);
*outRT = mLevelLayerRenderTargets[key];
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
}
......@@ -3144,16 +3047,12 @@ gl::Error TextureStorage11_2DArray::releaseAssociatedImage(const gl::ImageIndex
{
// Force the image to recover from storage before its data is overwritten.
// This will reset mAssociatedImages[level] to nullptr too.
gl::Error error = mAssociatedImages[key]->recoverFromAssociatedStorage();
if (error.isError())
{
return error;
}
ANGLE_TRY(mAssociatedImages[key]->recoverFromAssociatedStorage());
}
}
}
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_2DArray::getResource(ID3D11Resource **outResource)
......@@ -3418,11 +3317,7 @@ gl::Error TextureStorage11_2DArray::getSwizzleRenderTarget(int mipLevel,
if (!mSwizzleRenderTargets[mipLevel])
{
ID3D11Resource *swizzleTexture = nullptr;
gl::Error error = getSwizzleTexture(&swizzleTexture);
if (error.isError())
{
return error;
}
ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
ID3D11Device *device = mRenderer->getDevice();
......@@ -3446,7 +3341,7 @@ gl::Error TextureStorage11_2DArray::getSwizzleRenderTarget(int mipLevel,
}
*outRTV = mSwizzleRenderTargets[mipLevel];
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
gl::Error TextureStorage11_2DArray::createDropStencilTexture()
......
src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp
......@@ -182,12 +182,8 @@ gl::Error VertexArray11::updateDirtyAndDynamicAttribs(VertexDataManager *vertexD
break;
case VertexStorageType::STATIC:
{
auto error =
VertexDataManager::StoreStaticAttrib(translatedAttrib, count, instances);
if (error.isError())
{
return error;
}
ANGLE_TRY(
VertexDataManager::StoreStaticAttrib(translatedAttrib, count, instances));
break;
}
case VertexStorageType::CURRENT_VALUE:
......
src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp
......@@ -120,11 +120,7 @@ gl::Error VertexBuffer11::storeVertexAttributes(const gl::VertexAttribute &attri
int inputStride = static_cast<int>(ComputeVertexAttributeStride(attrib));
// This will map the resource if it isn't already mapped.
gl::Error error = mapResource();
if (error.isError())
{
return error;
}
ANGLE_TRY(mapResource());
uint8_t *output = mMappedResourceData + offset;
......@@ -141,7 +137,7 @@ gl::Error VertexBuffer11::storeVertexAttributes(const gl::VertexAttribute &attri
ASSERT(vertexFormatInfo.copyFunction != NULL);
vertexFormatInfo.copyFunction(input, inputStride, count, output);
return gl::Error(GL_NO_ERROR);
return gl::NoError();
}
unsigned int VertexBuffer11::getBufferSize() const
......
src/libANGLE/renderer/d3d/d3d9/Blit9.cpp
......@@ -145,13 +145,7 @@ gl::Error Blit9::setShader(ShaderId source, const char *profile,
{
const BYTE* shaderCode = g_shaderCode[source];
size_t shaderSize = g_shaderSize[source];
gl::Error error = (mRenderer->*createShader)(reinterpret_cast<const DWORD*>(shaderCode), shaderSize, &shader);
if (error.isError())
{
return error;
}
ANGLE_TRY((mRenderer->*createShader)(reinterpret_cast<const DWORD*>(shaderCode), shaderSize, &shader));
mCompiledShaders[source] = shader;
}
......@@ -190,18 +184,10 @@ RECT Blit9::getSurfaceRect(IDirect3DSurface9 *surface) const
gl::Error Blit9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
{
gl::Error error = initialize();
if (error.isError())
{
return error;
}
ANGLE_TRY(initialize());
IDirect3DTexture9 *texture = NULL;
error = copySurfaceToTexture(source, getSurfaceRect(source), &texture);
if (error.isError())
{
return error;
}
ANGLE_TRY(copySurfaceToTexture(source, getSurfaceRect(source), &texture));
IDirect3DDevice9 *device = mRenderer->getDevice();
......@@ -230,21 +216,13 @@ gl::Error Blit9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
gl::Error Blit9::copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, const gl::Offset &destOffset, TextureStorage *storage, GLint level)
{
gl::Error error = initialize();
if (error.isError())
{
return error;
}
ANGLE_TRY(initialize());
const gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
ASSERT(colorbuffer);
RenderTarget9 *renderTarget9 = nullptr;
error = colorbuffer->getRenderTarget(&renderTarget9);
if (error.isError())
{
return error;
}
ANGLE_TRY(colorbuffer->getRenderTarget(&renderTarget9));
ASSERT(renderTarget9);
IDirect3DSurface9 *source = renderTarget9->getSurface();
......@@ -252,7 +230,7 @@ gl::Error Blit9::copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRe
IDirect3DSurface9 *destSurface = NULL;
TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage);
error = storage9->getSurfaceLevel(GL_TEXTURE_2D, level, true, &destSurface);
gl::Error error = storage9->getSurfaceLevel(GL_TEXTURE_2D, level, true, &destSurface);
if (error.isError())
{
SafeRelease(source);
......
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