blob: 40666cbef5d78e1054354c7e7e812d2e307db609 [file] [log] [blame]
//
// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Image11.h: Implements the rx::Image11 class, which acts as the interface to
// the actual underlying resources of a Texture
#include "libANGLE/renderer/d3d/d3d11/Image11.h"
#include "common/utilities.h"
#include "libANGLE/Context.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
namespace rx
{
Image11::Image11(Renderer11 *renderer)
: mRenderer(renderer),
mDXGIFormat(DXGI_FORMAT_UNKNOWN),
mStagingTexture(),
mStagingSubresource(0),
mRecoverFromStorage(false),
mAssociatedStorage(nullptr),
mAssociatedImageIndex(),
mRecoveredFromStorageCount(0)
{}
Image11::~Image11()
{
disassociateStorage();
releaseStagingTexture();
}
// static
angle::Result Image11::GenerateMipmap(const gl::Context *context,
Image11 *dest,
Image11 *src,
const Renderer11DeviceCaps &rendererCaps)
{
ASSERT(src->getDXGIFormat() == dest->getDXGIFormat());
ASSERT(src->getWidth() == 1 || src->getWidth() / 2 == dest->getWidth());
ASSERT(src->getHeight() == 1 || src->getHeight() / 2 == dest->getHeight());
D3D11_MAPPED_SUBRESOURCE destMapped;
ANGLE_TRY(dest->map(context, D3D11_MAP_WRITE, &destMapped));
d3d11::ScopedUnmapper<Image11> destRAII(dest);
D3D11_MAPPED_SUBRESOURCE srcMapped;
ANGLE_TRY(src->map(context, D3D11_MAP_READ, &srcMapped));
d3d11::ScopedUnmapper<Image11> srcRAII(src);
const uint8_t *sourceData = static_cast<const uint8_t *>(srcMapped.pData);
uint8_t *destData = static_cast<uint8_t *>(destMapped.pData);
auto mipGenerationFunction =
d3d11::Format::Get(src->getInternalFormat(), rendererCaps).format().mipGenerationFunction;
mipGenerationFunction(src->getWidth(), src->getHeight(), src->getDepth(), sourceData,
srcMapped.RowPitch, srcMapped.DepthPitch, destData, destMapped.RowPitch,
destMapped.DepthPitch);
dest->markDirty();
return angle::Result::Continue;
}
// static
angle::Result Image11::CopyImage(const gl::Context *context,
Image11 *dest,
Image11 *source,
const gl::Box &sourceBox,
const gl::Offset &destOffset,
bool unpackFlipY,
bool unpackPremultiplyAlpha,
bool unpackUnmultiplyAlpha,
const Renderer11DeviceCaps &rendererCaps)
{
D3D11_MAPPED_SUBRESOURCE destMapped;
ANGLE_TRY(dest->map(context, D3D11_MAP_WRITE, &destMapped));
d3d11::ScopedUnmapper<Image11> destRAII(dest);
D3D11_MAPPED_SUBRESOURCE srcMapped;
ANGLE_TRY(source->map(context, D3D11_MAP_READ, &srcMapped));
d3d11::ScopedUnmapper<Image11> sourceRAII(source);
const auto &sourceFormat =
d3d11::Format::Get(source->getInternalFormat(), rendererCaps).format();
GLuint sourcePixelBytes =
gl::GetSizedInternalFormatInfo(sourceFormat.fboImplementationInternalFormat).pixelBytes;
GLenum destUnsizedFormat = gl::GetUnsizedFormat(dest->getInternalFormat());
const auto &destFormat = d3d11::Format::Get(dest->getInternalFormat(), rendererCaps).format();
const auto &destFormatInfo =
gl::GetSizedInternalFormatInfo(destFormat.fboImplementationInternalFormat);
GLuint destPixelBytes = destFormatInfo.pixelBytes;
const uint8_t *sourceData = static_cast<const uint8_t *>(srcMapped.pData) +
sourceBox.x * sourcePixelBytes + sourceBox.y * srcMapped.RowPitch +
sourceBox.z * srcMapped.DepthPitch;
uint8_t *destData = static_cast<uint8_t *>(destMapped.pData) + destOffset.x * destPixelBytes +
destOffset.y * destMapped.RowPitch + destOffset.z * destMapped.DepthPitch;
CopyImageCHROMIUM(sourceData, srcMapped.RowPitch, sourcePixelBytes, srcMapped.DepthPitch,
sourceFormat.pixelReadFunction, destData, destMapped.RowPitch, destPixelBytes,
destMapped.DepthPitch, destFormat.pixelWriteFunction, destUnsizedFormat,
destFormatInfo.componentType, sourceBox.width, sourceBox.height,
sourceBox.depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
dest->markDirty();
return angle::Result::Continue;
}
bool Image11::isDirty() const
{
// If mDirty is true AND mStagingTexture doesn't exist AND mStagingTexture doesn't need to be
// recovered from TextureStorage AND the texture doesn't require init data (i.e. a blank new
// texture will suffice) AND robust resource initialization is not enabled then isDirty should
// still return false.
if (mDirty && !mStagingTexture.valid() && !mRecoverFromStorage)
{
const Renderer11DeviceCaps &deviceCaps = mRenderer->getRenderer11DeviceCaps();
const auto &formatInfo = d3d11::Format::Get(mInternalFormat, deviceCaps);
if (formatInfo.dataInitializerFunction == nullptr)
{
return false;
}
}
return mDirty;
}
angle::Result Image11::copyToStorage(const gl::Context *context,
TextureStorage *storage,
const gl::ImageIndex &index,
const gl::Box &region)
{
TextureStorage11 *storage11 = GetAs<TextureStorage11>(storage);
// If an app's behavior results in an Image11 copying its data to/from to a TextureStorage
// multiple times, then we should just keep the staging texture around to prevent the copying
// from impacting perf. We allow the Image11 to copy its data to/from TextureStorage once. This
// accounts for an app making a late call to glGenerateMipmap.
bool attemptToReleaseStagingTexture = (mRecoveredFromStorageCount < 2);
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.
ANGLE_TRY(storage11->releaseAssociatedImage(context, index, this));
}
const TextureHelper11 *stagingTexture = nullptr;
unsigned int stagingSubresourceIndex = 0;
ANGLE_TRY(getStagingTexture(context, &stagingTexture, &stagingSubresourceIndex));
ANGLE_TRY(storage11->updateSubresourceLevel(context, *stagingTexture, stagingSubresourceIndex,
index, region));
// Once the image data has been copied into the Storage, we can release it locally.
if (attemptToReleaseStagingTexture)
{
storage11->associateImage(this, index);
releaseStagingTexture();
mRecoverFromStorage = true;
mAssociatedStorage = storage11;
mAssociatedImageIndex = index;
}
return angle::Result::Continue;
}
void Image11::verifyAssociatedStorageValid(TextureStorage11 *textureStorage) const
{
ASSERT(mAssociatedStorage == textureStorage);
}
angle::Result Image11::recoverFromAssociatedStorage(const gl::Context *context)
{
if (mRecoverFromStorage)
{
ANGLE_TRY(createStagingTexture(context));
mAssociatedStorage->verifyAssociatedImageValid(mAssociatedImageIndex, this);
// CopySubResource from the Storage to the Staging texture
gl::Box region(0, 0, 0, mWidth, mHeight, mDepth);
ANGLE_TRY(mAssociatedStorage->copySubresourceLevel(
context, mStagingTexture, mStagingSubresource, mAssociatedImageIndex, region));
mRecoveredFromStorageCount += 1;
// Reset all the recovery parameters, even if the texture storage association is broken.
disassociateStorage();
}
return angle::Result::Continue;
}
void Image11::disassociateStorage()
{
if (mRecoverFromStorage)
{
// Make the texturestorage release the Image11 too
mAssociatedStorage->disassociateImage(mAssociatedImageIndex, this);
mRecoverFromStorage = false;
mAssociatedStorage = nullptr;
mAssociatedImageIndex = gl::ImageIndex();
}
}
bool Image11::redefine(gl::TextureType type,
GLenum internalformat,
const gl::Extents &size,
bool forceRelease)
{
if (mWidth != size.width || mHeight != size.height || mInternalFormat != internalformat ||
forceRelease)
{
// End the association with the TextureStorage, since that data will be out of date.
// Also reset mRecoveredFromStorageCount since this Image is getting completely redefined.
disassociateStorage();
mRecoveredFromStorageCount = 0;
mWidth = size.width;
mHeight = size.height;
mDepth = size.depth;
mInternalFormat = internalformat;
mType = type;
// compute the d3d format that will be used
const d3d11::Format &formatInfo =
d3d11::Format::Get(internalformat, mRenderer->getRenderer11DeviceCaps());
mDXGIFormat = formatInfo.texFormat;
mRenderable = (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN);
releaseStagingTexture();
mDirty = (formatInfo.dataInitializerFunction != nullptr);
return true;
}
return false;
}
DXGI_FORMAT Image11::getDXGIFormat() const
{
// this should only happen if the image hasn't been redefined first
// which would be a bug by the caller
ASSERT(mDXGIFormat != DXGI_FORMAT_UNKNOWN);
return mDXGIFormat;
}
// Store the pixel rectangle designated by xoffset,yoffset,width,height with pixels stored as
// format/type at input
// into the target pixel rectangle.
angle::Result Image11::loadData(const gl::Context *context,
const gl::Box &area,
const gl::PixelUnpackState &unpack,
GLenum type,
const void *input,
bool applySkipImages)
{
Context11 *context11 = GetImplAs<Context11>(context);
const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat);
GLuint inputRowPitch = 0;
ANGLE_CHECK_GL_MATH(context11, formatInfo.computeRowPitch(type, area.width, unpack.alignment,
unpack.rowLength, &inputRowPitch));
GLuint inputDepthPitch = 0;
ANGLE_CHECK_GL_MATH(context11, formatInfo.computeDepthPitch(area.height, unpack.imageHeight,
inputRowPitch, &inputDepthPitch));
GLuint inputSkipBytes = 0;
ANGLE_CHECK_GL_MATH(context11,
formatInfo.computeSkipBytes(type, inputRowPitch, inputDepthPitch, unpack,
applySkipImages, &inputSkipBytes));
const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat);
GLuint outputPixelSize = dxgiFormatInfo.pixelBytes;
const d3d11::Format &d3dFormatInfo =
d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps());
LoadImageFunction loadFunction = d3dFormatInfo.getLoadFunctions()(type).loadFunction;
D3D11_MAPPED_SUBRESOURCE mappedImage;
ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage));
uint8_t *offsetMappedData = (static_cast<uint8_t *>(mappedImage.pData) +
(area.y * mappedImage.RowPitch + area.x * outputPixelSize +
area.z * mappedImage.DepthPitch));
loadFunction(area.width, area.height, area.depth,
static_cast<const uint8_t *>(input) + inputSkipBytes, inputRowPitch,
inputDepthPitch, offsetMappedData, mappedImage.RowPitch, mappedImage.DepthPitch);
unmap();
return angle::Result::Continue;
}
angle::Result Image11::loadCompressedData(const gl::Context *context,
const gl::Box &area,
const void *input)
{
Context11 *context11 = GetImplAs<Context11>(context);
const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat);
GLuint inputRowPitch = 0;
ANGLE_CHECK_GL_MATH(
context11, formatInfo.computeRowPitch(GL_UNSIGNED_BYTE, area.width, 1, 0, &inputRowPitch));
GLuint inputDepthPitch = 0;
ANGLE_CHECK_GL_MATH(
context11, formatInfo.computeDepthPitch(area.height, 0, inputRowPitch, &inputDepthPitch));
const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat);
GLuint outputPixelSize = dxgiFormatInfo.pixelBytes;
GLuint outputBlockWidth = dxgiFormatInfo.blockWidth;
GLuint outputBlockHeight = dxgiFormatInfo.blockHeight;
ASSERT(area.x % outputBlockWidth == 0);
ASSERT(area.y % outputBlockHeight == 0);
const d3d11::Format &d3dFormatInfo =
d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps());
LoadImageFunction loadFunction =
d3dFormatInfo.getLoadFunctions()(GL_UNSIGNED_BYTE).loadFunction;
D3D11_MAPPED_SUBRESOURCE mappedImage;
ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage));
uint8_t *offsetMappedData =
static_cast<uint8_t *>(mappedImage.pData) +
((area.y / outputBlockHeight) * mappedImage.RowPitch +
(area.x / outputBlockWidth) * outputPixelSize + area.z * mappedImage.DepthPitch);
loadFunction(area.width, area.height, area.depth, static_cast<const uint8_t *>(input),
inputRowPitch, inputDepthPitch, offsetMappedData, mappedImage.RowPitch,
mappedImage.DepthPitch);
unmap();
return angle::Result::Continue;
}
angle::Result Image11::copyFromTexStorage(const gl::Context *context,
const gl::ImageIndex &imageIndex,
TextureStorage *source)
{
TextureStorage11 *storage11 = GetAs<TextureStorage11>(source);
const TextureHelper11 *textureHelper = nullptr;
ANGLE_TRY(storage11->getResource(context, &textureHelper));
UINT subresourceIndex = 0;
ANGLE_TRY(storage11->getSubresourceIndex(context, imageIndex, &subresourceIndex));
gl::Box sourceBox(0, 0, 0, mWidth, mHeight, mDepth);
return copyWithoutConversion(context, gl::Offset(), sourceBox, *textureHelper,
subresourceIndex);
}
angle::Result Image11::copyFromFramebuffer(const gl::Context *context,
const gl::Offset &destOffset,
const gl::Rectangle &sourceArea,
const gl::Framebuffer *sourceFBO)
{
const gl::FramebufferAttachment *srcAttachment = sourceFBO->getReadColorbuffer();
ASSERT(srcAttachment);
GLenum sourceInternalFormat = srcAttachment->getFormat().info->sizedInternalFormat;
const auto &d3d11Format =
d3d11::Format::Get(sourceInternalFormat, mRenderer->getRenderer11DeviceCaps());
if (d3d11Format.texFormat == mDXGIFormat && sourceInternalFormat == mInternalFormat)
{
RenderTarget11 *rt11 = nullptr;
ANGLE_TRY(srcAttachment->getRenderTarget(context, &rt11));
ASSERT(rt11->getTexture().get());
TextureHelper11 textureHelper = rt11->getTexture();
unsigned int sourceSubResource = rt11->getSubresourceIndex();
gl::Box sourceBox(sourceArea.x, sourceArea.y, 0, sourceArea.width, sourceArea.height, 1);
return copyWithoutConversion(context, destOffset, sourceBox, textureHelper,
sourceSubResource);
}
// This format requires conversion, so we must copy the texture to staging and manually convert
// via readPixels
D3D11_MAPPED_SUBRESOURCE mappedImage;
ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage));
// determine the offset coordinate into the destination buffer
const auto &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat);
GLsizei rowOffset = dxgiFormatInfo.pixelBytes * destOffset.x;
uint8_t *dataOffset = static_cast<uint8_t *>(mappedImage.pData) +
mappedImage.RowPitch * destOffset.y + rowOffset +
destOffset.z * mappedImage.DepthPitch;
const gl::InternalFormat &destFormatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat);
const auto &destD3D11Format =
d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps());
auto loadFunction = destD3D11Format.getLoadFunctions()(destFormatInfo.type);
angle::Result result = angle::Result::Continue;
if (loadFunction.requiresConversion)
{
size_t bufferSize = destFormatInfo.pixelBytes * sourceArea.width * sourceArea.height;
angle::MemoryBuffer *memoryBuffer = nullptr;
result = mRenderer->getScratchMemoryBuffer(GetImplAs<Context11>(context), bufferSize,
&memoryBuffer);
if (result == angle::Result::Continue)
{
GLuint memoryBufferRowPitch = destFormatInfo.pixelBytes * sourceArea.width;
result = mRenderer->readFromAttachment(
context, *srcAttachment, sourceArea, destFormatInfo.format, destFormatInfo.type,
memoryBufferRowPitch, gl::PixelPackState(), memoryBuffer->data());
loadFunction.loadFunction(sourceArea.width, sourceArea.height, 1, memoryBuffer->data(),
memoryBufferRowPitch, 0, dataOffset, mappedImage.RowPitch,
mappedImage.DepthPitch);
}
}
else
{
result = mRenderer->readFromAttachment(
context, *srcAttachment, sourceArea, destFormatInfo.format, destFormatInfo.type,
mappedImage.RowPitch, gl::PixelPackState(), dataOffset);
}
unmap();
mDirty = true;
return result;
}
angle::Result Image11::copyWithoutConversion(const gl::Context *context,
const gl::Offset &destOffset,
const gl::Box &sourceArea,
const TextureHelper11 &textureHelper,
UINT sourceSubResource)
{
// No conversion needed-- use copyback fastpath
const TextureHelper11 *stagingTexture = nullptr;
unsigned int stagingSubresourceIndex = 0;
ANGLE_TRY(getStagingTexture(context, &stagingTexture, &stagingSubresourceIndex));
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
const gl::Extents &extents = textureHelper.getExtents();
D3D11_BOX srcBox;
srcBox.left = sourceArea.x;
srcBox.right = sourceArea.x + sourceArea.width;
srcBox.top = sourceArea.y;
srcBox.bottom = sourceArea.y + sourceArea.height;
srcBox.front = sourceArea.z;
srcBox.back = sourceArea.z + sourceArea.depth;
if (textureHelper.is2D() && textureHelper.getSampleCount() > 1)
{
D3D11_TEXTURE2D_DESC resolveDesc;
resolveDesc.Width = extents.width;
resolveDesc.Height = extents.height;
resolveDesc.MipLevels = 1;
resolveDesc.ArraySize = 1;
resolveDesc.Format = textureHelper.getFormat();
resolveDesc.SampleDesc.Count = 1;
resolveDesc.SampleDesc.Quality = 0;
resolveDesc.Usage = D3D11_USAGE_DEFAULT;
resolveDesc.BindFlags = 0;
resolveDesc.CPUAccessFlags = 0;
resolveDesc.MiscFlags = 0;
d3d11::Texture2D resolveTex;
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), resolveDesc, &resolveTex));
deviceContext->ResolveSubresource(resolveTex.get(), 0, textureHelper.get(),
sourceSubResource, textureHelper.getFormat());
deviceContext->CopySubresourceRegion(stagingTexture->get(), stagingSubresourceIndex,
destOffset.x, destOffset.y, destOffset.z,
resolveTex.get(), 0, &srcBox);
}
else
{
deviceContext->CopySubresourceRegion(stagingTexture->get(), stagingSubresourceIndex,
destOffset.x, destOffset.y, destOffset.z,
textureHelper.get(), sourceSubResource, &srcBox);
}
mDirty = true;
return angle::Result::Continue;
}
angle::Result Image11::getStagingTexture(const gl::Context *context,
const TextureHelper11 **outStagingTexture,
unsigned int *outSubresourceIndex)
{
ANGLE_TRY(createStagingTexture(context));
*outStagingTexture = &mStagingTexture;
*outSubresourceIndex = mStagingSubresource;
return angle::Result::Continue;
}
void Image11::releaseStagingTexture()
{
mStagingTexture.reset();
}
angle::Result Image11::createStagingTexture(const gl::Context *context)
{
if (mStagingTexture.valid())
{
return angle::Result::Continue;
}
ASSERT(mWidth > 0 && mHeight > 0 && mDepth > 0);
const DXGI_FORMAT dxgiFormat = getDXGIFormat();
const auto &formatInfo =
d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps());
int lodOffset = 1;
GLsizei width = mWidth;
GLsizei height = mHeight;
// adjust size if needed for compressed textures
d3d11::MakeValidSize(false, dxgiFormat, &width, &height, &lodOffset);
Context11 *context11 = GetImplAs<Context11>(context);
switch (mType)
{
case gl::TextureType::_3D:
{
D3D11_TEXTURE3D_DESC desc;
desc.Width = width;
desc.Height = height;
desc.Depth = mDepth;
desc.MipLevels = lodOffset + 1;
desc.Format = dxgiFormat;
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
if (formatInfo.dataInitializerFunction != nullptr)
{
gl::TexLevelArray<D3D11_SUBRESOURCE_DATA> initialData;
ANGLE_TRY(d3d11::GenerateInitialTextureData(
context, mInternalFormat, mRenderer->getRenderer11DeviceCaps(), width, height,
mDepth, lodOffset + 1, &initialData));
ANGLE_TRY(mRenderer->allocateTexture(context11, desc, formatInfo,
initialData.data(), &mStagingTexture));
}
else
{
ANGLE_TRY(
mRenderer->allocateTexture(context11, desc, formatInfo, &mStagingTexture));
}
mStagingTexture.setDebugName("Image11::StagingTexture3D");
mStagingSubresource = D3D11CalcSubresource(lodOffset, 0, lodOffset + 1);
}
break;
case gl::TextureType::_2D:
case gl::TextureType::_2DArray:
case gl::TextureType::CubeMap:
{
D3D11_TEXTURE2D_DESC desc;
desc.Width = width;
desc.Height = height;
desc.MipLevels = lodOffset + 1;
desc.ArraySize = 1;
desc.Format = dxgiFormat;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
if (formatInfo.dataInitializerFunction != nullptr)
{
gl::TexLevelArray<D3D11_SUBRESOURCE_DATA> initialData;
ANGLE_TRY(d3d11::GenerateInitialTextureData(
context, mInternalFormat, mRenderer->getRenderer11DeviceCaps(), width, height,
1, lodOffset + 1, &initialData));
ANGLE_TRY(mRenderer->allocateTexture(context11, desc, formatInfo,
initialData.data(), &mStagingTexture));
}
else
{
ANGLE_TRY(
mRenderer->allocateTexture(context11, desc, formatInfo, &mStagingTexture));
}
mStagingTexture.setDebugName("Image11::StagingTexture2D");
mStagingSubresource = D3D11CalcSubresource(lodOffset, 0, lodOffset + 1);
}
break;
default:
UNREACHABLE();
}
mDirty = false;
return angle::Result::Continue;
}
angle::Result Image11::map(const gl::Context *context,
D3D11_MAP mapType,
D3D11_MAPPED_SUBRESOURCE *map)
{
// We must recover from the TextureStorage if necessary, even for D3D11_MAP_WRITE.
ANGLE_TRY(recoverFromAssociatedStorage(context));
const TextureHelper11 *stagingTexture = nullptr;
unsigned int subresourceIndex = 0;
ANGLE_TRY(getStagingTexture(context, &stagingTexture, &subresourceIndex));
ASSERT(stagingTexture && stagingTexture->valid());
ANGLE_TRY(
mRenderer->mapResource(context, stagingTexture->get(), subresourceIndex, mapType, 0, map));
mDirty = true;
return angle::Result::Continue;
}
void Image11::unmap()
{
if (mStagingTexture.valid())
{
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
deviceContext->Unmap(mStagingTexture.get(), mStagingSubresource);
}
}
} // namespace rx