Skip to content

A
angle
Commit e34deaa3 by Jamie Madill
Options

Revert "Clean up Buffer11."

Fails Clang-win because of std::forward ..\..\third_party\angle\src\libANGLE/Error.h(60,40): error: no matching function for call to 'forward' BUG=598944 BUG=angleproject:1327 BUG=angleproject:1310 This reverts commit 041d678b. Change-Id: I9fb0685cd01090b1faf8417ffa3c9b49eeb4510e Reviewed-on: https://chromium-review.googlesource.com/336040Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 041d678b
Showing with 306 additions and 544 deletions
src/libANGLE/Error.h
......@@ -53,13 +53,7 @@ class ErrorOrResult
{
public:
ErrorOrResult(const gl::Error &error) : mError(error) {}
ErrorOrResult(gl::Error &&error) : mError(std::move(error)) {}
template <typename ArgT>
ErrorOrResult(ArgT &&result)
: mError(GL_NO_ERROR), mResult(std::forward<T>(result))
{
}
ErrorOrResult(T &&result) : mError(GL_NO_ERROR), mResult(std::move(result)) {}
bool isError() const { return mError.isError(); }
const gl::Error &getError() const { return mError; }
......
src/libANGLE/renderer/d3d/BufferD3D.h
......@@ -37,7 +37,7 @@ class BufferD3D : public BufferImpl
virtual size_t getSize() const = 0;
virtual bool supportsDirectBinding() const = 0;
virtual gl::Error markTransformFeedbackUsage() = 0;
virtual void markTransformFeedbackUsage() = 0;
virtual gl::Error getData(const uint8_t **outData) = 0;
StaticVertexBufferInterface *getStaticVertexBuffer(const gl::VertexAttribute &attribute);
......
src/libANGLE/renderer/d3d/RendererD3D.cpp
......@@ -272,11 +272,7 @@ gl::Error RendererD3D::genericDrawArrays(const gl::Data &data,
if (data.state->isTransformFeedbackActiveUnpaused())
{
error = markTransformFeedbackUsage(data);
if (error.isError())
{
return error;
}
markTransformFeedbackUsage(data);
}
}
......@@ -513,7 +509,7 @@ bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode)
return false;
}
gl::Error RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
void RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
{
const gl::TransformFeedback *transformFeedback = data.state->getCurrentTransformFeedback();
for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++)
......@@ -522,15 +518,9 @@ gl::Error RendererD3D::markTransformFeedbackUsage(const gl::Data &data)
if (binding.get() != nullptr)
{
BufferD3D *bufferD3D = GetImplAs<BufferD3D>(binding.get());
auto error = bufferD3D->markTransformFeedbackUsage();
if (error.isError())
{
return error;
}
bufferD3D->markTransformFeedbackUsage();
}
}
return gl::Error(GL_NO_ERROR);
}
size_t RendererD3D::getBoundFramebufferTextures(const gl::Data &data, FramebufferTextureArray *outTextureArray)
......
src/libANGLE/renderer/d3d/RendererD3D.h
......@@ -180,7 +180,7 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
GLenum mode,
GLenum type,
TranslatedIndexData *indexInfo) = 0;
virtual gl::Error applyTransformFeedbackBuffers(const gl::State &state) = 0;
virtual void applyTransformFeedbackBuffers(const gl::State& state) = 0;
virtual unsigned int getReservedVertexUniformVectors() const = 0;
virtual unsigned int getReservedFragmentUniformVectors() const = 0;
......@@ -326,7 +326,7 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
gl::Error applyTextures(const gl::Data &data);
bool skipDraw(const gl::Data &data, GLenum drawMode);
gl::Error markTransformFeedbackUsage(const gl::Data &data);
void markTransformFeedbackUsage(const gl::Data &data);
size_t getBoundFramebufferTextures(const gl::Data &data, FramebufferTextureArray *outTextureArray);
gl::Texture *getIncompleteTexture(GLenum type);
......
src/libANGLE/renderer/d3d/VertexBuffer.cpp
......@@ -111,7 +111,7 @@ gl::ErrorOrResult<unsigned int> VertexBufferInterface::getSpaceRequired(
"Vertex buffer overflow in VertexBufferInterface::getSpaceRequired.");
}
return alignedSpaceRequired;
return std::move(alignedSpaceRequired);
}
gl::Error VertexBufferInterface::discard()
......
src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp
......@@ -18,9 +18,6 @@
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
namespace rx
{
namespace
{
......@@ -30,15 +27,10 @@ GLuint ReadIndexValueFromIndices(const uint8_t *data, size_t index)
return reinterpret_cast<const T *>(data)[index];
}
typedef GLuint (*ReadIndexValueFunction)(const uint8_t *data, size_t index);
}
enum class CopyResult
namespace rx
{
RECREATED,
NOT_RECREATED,
};
} // anonymous namespace
PackPixelsParams::PackPixelsParams()
: format(GL_NONE), type(GL_NONE), outputPitch(0), packBuffer(nullptr), offset(0)
{
......@@ -91,7 +83,7 @@ D3D11_MAP GetD3DMapTypeFromBits(GLbitfield access)
return D3D11_MAP_READ;
}
}
} // namespace gl_d3d11
}
// Each instance of Buffer11::BufferStorage is specialized for a class of D3D binding points
// - vertex/transform feedback buffers
......@@ -110,16 +102,13 @@ class Buffer11::BufferStorage : angle::NonCopyable
virtual bool isMappable() const = 0;
virtual gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) = 0;
virtual bool copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) = 0;
virtual gl::Error resize(size_t size, bool preserveData) = 0;
virtual gl::Error map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut) = 0;
virtual uint8_t *map(size_t offset, size_t length, GLbitfield access) = 0;
virtual void unmap() = 0;
gl::Error setData(const uint8_t *data, size_t offset, size_t size);
......@@ -144,16 +133,13 @@ class Buffer11::NativeStorage : public Buffer11::BufferStorage
bool isMappable() const override { return mUsage == BUFFER_USAGE_STAGING; }
ID3D11Buffer *getNativeStorage() const { return mNativeStorage; }
gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
bool copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
gl::Error resize(size_t size, bool preserveData) override;
gl::Error map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut) override;
uint8_t *map(size_t offset, size_t length, GLbitfield access) override;
void unmap() override;
private:
......@@ -176,26 +162,26 @@ class Buffer11::EmulatedIndexedStorage : public Buffer11::BufferStorage
bool isMappable() const override { return true; }
gl::ErrorOrResult<ID3D11Buffer *> getNativeStorage(SourceIndexData *indexInfo,
const TranslatedAttribute &attribute);
ID3D11Buffer *getNativeStorage();
gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
bool copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
gl::Error resize(size_t size, bool preserveData) override;
gl::Error map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut) override;
uint8_t *map(size_t offset, size_t length, GLbitfield access) override;
void unmap() override;
bool update(SourceIndexData *indexInfo, const TranslatedAttribute *attribute);
private:
ID3D11Buffer *mNativeStorage; // contains expanded data for use by D3D
MemoryBuffer mMemoryBuffer; // original data (not expanded)
MemoryBuffer mIndicesMemoryBuffer; // indices data
SourceIndexData mIndexInfo; // indices information
size_t mAttributeStride; // per element stride in bytes
size_t mAttributeOffset; // starting offset
};
// Pack storage represents internal storage for pack buffers. We implement pack buffers
......@@ -207,16 +193,13 @@ class Buffer11::PackStorage : public Buffer11::BufferStorage
~PackStorage() override;
bool isMappable() const override { return true; }
gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
bool copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
gl::Error resize(size_t size, bool preserveData) override;
gl::Error map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut) override;
uint8_t *map(size_t offset, size_t length, GLbitfield access) override;
void unmap() override;
gl::Error packPixels(const gl::FramebufferAttachment &readAttachment,
......@@ -242,16 +225,13 @@ class Buffer11::SystemMemoryStorage : public Buffer11::BufferStorage
~SystemMemoryStorage() override {}
bool isMappable() const override { return true; }
gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
bool copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset) override;
gl::Error resize(size_t size, bool preserveData) override;
gl::Error map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut) override;
uint8_t *map(size_t offset, size_t length, GLbitfield access) override;
void unmap() override;
MemoryBuffer *getSystemCopy() { return &mSystemCopy; }
......@@ -302,15 +282,15 @@ gl::Error Buffer11::setData(const void *data, size_t size, GLenum usage)
gl::Error Buffer11::getData(const uint8_t **outData)
{
auto systemOrError = getSystemMemoryStorage();
if (systemOrError.isError())
SystemMemoryStorage *systemMemoryStorage = nullptr;
gl::Error error = getSystemMemoryStorage(&systemMemoryStorage);
if (error.isError())
{
*outData = nullptr;
return systemOrError.getError();
return error;
}
SystemMemoryStorage *systemMemoryStorage = systemOrError.getResult();
mReadUsageCount = 0;
ASSERT(systemMemoryStorage->getSize() >= mSize);
......@@ -319,16 +299,18 @@ gl::Error Buffer11::getData(const uint8_t **outData)
return gl::Error(GL_NO_ERROR);
}
gl::ErrorOrResult<Buffer11::SystemMemoryStorage *> Buffer11::getSystemMemoryStorage()
gl::Error Buffer11::getSystemMemoryStorage(SystemMemoryStorage **storageOut)
{
auto systemOrError = getBufferStorage(BUFFER_USAGE_SYSTEM_MEMORY);
if (systemOrError.isError())
BufferStorage *memStorageUntyped = getBufferStorage(BUFFER_USAGE_SYSTEM_MEMORY);
if (memStorageUntyped == nullptr)
{
return systemOrError.getError();
// TODO(jmadill): convert all to errors
return gl::Error(GL_OUT_OF_MEMORY);
}
auto resultT = GetAs<SystemMemoryStorage>(systemOrError.getResult());
return resultT;
*storageOut = GetAs<SystemMemoryStorage>(memStorageUntyped);
return gl::Error(GL_NO_ERROR);
}
gl::Error Buffer11::setSubData(const void *data, size_t size, size_t offset)
......@@ -342,23 +324,23 @@ gl::Error Buffer11::setSubData(const void *data, size_t size, size_t offset)
BufferStorage *writeBuffer = nullptr;
if (supportsDirectBinding())
{
auto stagingOrError = getStagingStorage();
if (stagingOrError.isError())
writeBuffer = getStagingStorage();
if (!writeBuffer)
{
return stagingOrError.getError();
return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal buffer.");
}
writeBuffer = stagingOrError.getResult();
}
else
{
auto systemOrError = getSystemMemoryStorage();
if (systemOrError.isError())
SystemMemoryStorage *systemMemoryStorage = nullptr;
gl::Error error = getSystemMemoryStorage(&systemMemoryStorage);
if (error.isError())
{
return systemOrError.getError();
return error;
}
writeBuffer = systemOrError.getResult();
writeBuffer = systemMemoryStorage;
}
ASSERT(writeBuffer);
......@@ -393,29 +375,13 @@ gl::Error Buffer11::copySubData(BufferImpl *source,
Buffer11 *sourceBuffer = GetAs<Buffer11>(source);
ASSERT(sourceBuffer != nullptr);
auto latestOrError = getLatestBufferStorage();
if (latestOrError.isError())
{
return latestOrError.getError();
}
BufferStorage *copyDest = latestOrError.getResult();
BufferStorage *copyDest = getLatestBufferStorage();
if (!copyDest)
{
auto stagingOrError = getStagingStorage();
if (stagingOrError.isError())
{
return stagingOrError.getError();
}
copyDest = stagingOrError.getResult();
copyDest = getStagingStorage();
}
auto sourceLatestOrError = sourceBuffer->getLatestBufferStorage();
if (sourceLatestOrError.isError())
{
return sourceLatestOrError.getError();
}
BufferStorage *copySource = sourceLatestOrError.getResult();
BufferStorage *copySource = sourceBuffer->getLatestBufferStorage();
if (!copySource || !copyDest)
{
......@@ -426,21 +392,11 @@ gl::Error Buffer11::copySubData(BufferImpl *source,
// pack buffer partner, because other native buffers can't be mapped
if (copyDest->getUsage() == BUFFER_USAGE_PIXEL_PACK && !copySource->isMappable())
{
auto sourceStagingOrError = sourceBuffer->getStagingStorage();
if (sourceStagingOrError.isError())
{
return sourceStagingOrError.getError();
}
copySource = sourceStagingOrError.getResult();
copySource = sourceBuffer->getStagingStorage();
}
else if (copySource->getUsage() == BUFFER_USAGE_PIXEL_PACK && !copyDest->isMappable())
{
auto stagingOrError = getStagingStorage();
if (stagingOrError.isError())
{
return stagingOrError.getError();
}
copyDest = stagingOrError.getResult();
copyDest = getStagingStorage();
}
// D3D11 does not allow overlapped copies until 11.1, and only if the
......@@ -450,29 +406,15 @@ gl::Error Buffer11::copySubData(BufferImpl *source,
{
if (copySource->getUsage() == BUFFER_USAGE_STAGING)
{
auto vertexOrError = getBufferStorage(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
if (vertexOrError.isError())
{
return vertexOrError.getError();
}
copySource = vertexOrError.getResult();
copySource = getBufferStorage(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
}
else
{
auto stagingOrError = getStagingStorage();
if (stagingOrError.isError())
{
return stagingOrError.getError();
}
copySource = stagingOrError.getResult();
copySource = getStagingStorage();
}
}
auto resultOrError = copyDest->copyFromStorage(copySource, sourceOffset, size, destOffset);
if (resultOrError.isError())
{
return resultOrError.getError();
}
copyDest->copyFromStorage(copySource, sourceOffset, size, destOffset);
copyDest->setDataRevision(copyDest->getDataRevision() + 1);
mSize = std::max<size_t>(mSize, destOffset + size);
......@@ -493,12 +435,7 @@ gl::Error Buffer11::mapRange(size_t offset, size_t length, GLbitfield access, GL
{
ASSERT(!mMappedStorage);
auto latestOrError = getLatestBufferStorage();
if (latestOrError.isError())
{
return latestOrError.getError();
}
BufferStorage *latestStorage = latestOrError.getResult();
BufferStorage *latestStorage = getLatestBufferStorage();
if (latestStorage && (latestStorage->getUsage() == BUFFER_USAGE_PIXEL_PACK ||
latestStorage->getUsage() == BUFFER_USAGE_STAGING))
{
......@@ -509,12 +446,7 @@ gl::Error Buffer11::mapRange(size_t offset, size_t length, GLbitfield access, GL
{
// Fall back to using the staging buffer if the latest storage does
// not exist or is not CPU-accessible.
auto stagingOrError = getStagingStorage();
if (stagingOrError.isError())
{
return stagingOrError.getError();
}
mMappedStorage = stagingOrError.getResult();
mMappedStorage = getStagingStorage();
}
if (!mMappedStorage)
......@@ -529,13 +461,11 @@ gl::Error Buffer11::mapRange(size_t offset, size_t length, GLbitfield access, GL
invalidateStaticData();
}
uint8_t *mappedBuffer = nullptr;
auto error = mMappedStorage->map(offset, length, access, &mappedBuffer);
if (error.isError())
uint8_t *mappedBuffer = mMappedStorage->map(offset, length, access);
if (!mappedBuffer)
{
return error;
return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal buffer.");
}
ASSERT(mappedBuffer);
*mapPtr = static_cast<GLvoid *>(mappedBuffer);
return gl::Error(GL_NO_ERROR);
......@@ -553,25 +483,20 @@ gl::Error Buffer11::unmap(GLboolean *result)
return gl::Error(GL_NO_ERROR);
}
gl::Error Buffer11::markTransformFeedbackUsage()
void Buffer11::markTransformFeedbackUsage()
{
auto tfOrError = getBufferStorage(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
if (tfOrError.isError())
{
return tfOrError.getError();
}
BufferStorage *transformFeedbackStorage =
getBufferStorage(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
BufferStorage *transformFeedbackStorage = tfOrError.getResult();
if (transformFeedbackStorage)
{
transformFeedbackStorage->setDataRevision(transformFeedbackStorage->getDataRevision() + 1);
}
invalidateStaticData();
return gl::Error(GL_NO_ERROR);
}
gl::Error Buffer11::markBufferUsage()
void Buffer11::markBufferUsage()
{
mReadUsageCount++;
......@@ -581,106 +506,87 @@ gl::Error Buffer11::markBufferUsage()
BufferStorage *&sysMemUsage = mBufferStorages[BUFFER_USAGE_SYSTEM_MEMORY];
if (mReadUsageCount > usageLimit && sysMemUsage != nullptr)
{
auto latestOrError = getLatestBufferStorage();
if (latestOrError.isError())
{
return latestOrError.getError();
}
if (latestOrError.getResult() != sysMemUsage)
if (getLatestBufferStorage() != sysMemUsage)
{
SafeDelete(sysMemUsage);
}
}
return gl::Error(GL_NO_ERROR);
}
gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getBuffer(BufferUsage usage)
ID3D11Buffer *Buffer11::getBuffer(BufferUsage usage)
{
gl::Error error = markBufferUsage();
if (error.isError())
{
return error;
}
markBufferUsage();
BufferStorage *bufferStorage = getBufferStorage(usage);
auto bufferOrError = getBufferStorage(usage);
if (bufferOrError.isError())
if (!bufferStorage)
{
return bufferOrError.getError();
// Storage out-of-memory
return nullptr;
}
return GetAs<NativeStorage>(bufferOrError.getResult())->getNativeStorage();
return GetAs<NativeStorage>(bufferStorage)->getNativeStorage();
}
gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getEmulatedIndexedBuffer(
SourceIndexData *indexInfo,
const TranslatedAttribute &attribute)
ID3D11Buffer *Buffer11::getEmulatedIndexedBuffer(SourceIndexData *indexInfo,
const TranslatedAttribute *attribute)
{
gl::Error error = markBufferUsage();
if (error.isError())
{
return error;
}
markBufferUsage();
ASSERT(indexInfo);
assert(indexInfo != nullptr);
assert(attribute != nullptr);
auto emulatedOrError = getBufferStorage(BUFFER_USAGE_EMULATED_INDEXED_VERTEX);
if (emulatedOrError.isError())
BufferStorage *bufferStorage = getBufferStorage(BUFFER_USAGE_EMULATED_INDEXED_VERTEX);
if (!bufferStorage)
{
return emulatedOrError.getError();
// Storage out-of-memory
return nullptr;
}
EmulatedIndexedStorage *emulatedStorage =
GetAs<EmulatedIndexedStorage>(emulatedOrError.getResult());
auto errorOrResult = emulatedStorage->getNativeStorage(indexInfo, attribute);
if (errorOrResult.isError())
EmulatedIndexedStorage *emulatedStorage = GetAs<EmulatedIndexedStorage>(bufferStorage);
if (!emulatedStorage->update(indexInfo, attribute))
{
return errorOrResult.getError();
// Storage out-of-memory
return nullptr;
}
return errorOrResult.getResult();
return emulatedStorage->getNativeStorage();
}
gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getConstantBufferRange(GLintptr offset, GLsizeiptr size)
ID3D11Buffer *Buffer11::getConstantBufferRange(GLintptr offset, GLsizeiptr size)
{
gl::Error error = markBufferUsage();
if (error.isError())
{
return error;
}
markBufferUsage();
BufferStorage *bufferStorage;
if (offset == 0)
{
auto uniformOrError = getBufferStorage(BUFFER_USAGE_UNIFORM);
if (uniformOrError.isError())
{
return uniformOrError.getError();
}
bufferStorage = uniformOrError.getResult();
bufferStorage = getBufferStorage(BUFFER_USAGE_UNIFORM);
}
else
{
auto constantOrError = getConstantBufferRangeStorage(offset, size);
if (constantOrError.isError())
{
return constantOrError.getError();
}
bufferStorage = constantOrError.getResult();
bufferStorage = getConstantBufferRangeStorage(offset, size);
}
if (!bufferStorage)
{
// Storage out-of-memory
return nullptr;
}
return GetAs<NativeStorage>(bufferStorage)->getNativeStorage();
}
gl::ErrorOrResult<ID3D11ShaderResourceView *> Buffer11::getSRV(DXGI_FORMAT srvFormat)
ID3D11ShaderResourceView *Buffer11::getSRV(DXGI_FORMAT srvFormat)
{
auto unpackOrError = getBufferStorage(BUFFER_USAGE_PIXEL_UNPACK);
if (unpackOrError.isError())
BufferStorage *storage = getBufferStorage(BUFFER_USAGE_PIXEL_UNPACK);
if (!storage)
{
return unpackOrError.getError();
// Storage out-of-memory
return nullptr;
}
BufferStorage *storage = unpackOrError.getResult();
ID3D11Buffer *buffer = GetAs<NativeStorage>(storage)->getNativeStorage();
auto bufferSRVIt = mBufferResourceViews.find(srvFormat);
......@@ -722,27 +628,18 @@ gl::ErrorOrResult<ID3D11ShaderResourceView *> Buffer11::getSRV(DXGI_FORMAT srvFo
gl::Error Buffer11::packPixels(const gl::FramebufferAttachment &readAttachment,
const PackPixelsParams &params)
{
auto packOrError = getPackStorage();
if (packOrError.isError())
{
return packOrError.getError();
}
PackStorage *packStorage = packOrError.getResult();
PackStorage *packStorage = getPackStorage();
BufferStorage *latestStorage = getLatestBufferStorage();
auto latestOrError = getLatestBufferStorage();
if (latestOrError.isError())
if (packStorage)
{
return latestOrError.getError();
}
BufferStorage *latestStorage = latestOrError.getResult();
ASSERT(packStorage);
gl::Error error = packStorage->packPixels(readAttachment, params);
if (error.isError())
{
return error;
gl::Error error = packStorage->packPixels(readAttachment, params);
if (error.isError())
{
return error;
}
packStorage->setDataRevision(latestStorage ? latestStorage->getDataRevision() + 1 : 1);
}
packStorage->setDataRevision(latestStorage ? latestStorage->getDataRevision() + 1 : 1);
return gl::Error(GL_NO_ERROR);
}
......@@ -760,7 +657,7 @@ size_t Buffer11::getTotalCPUBufferMemoryBytes() const
return allocationSize;
}
gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getBufferStorage(BufferUsage usage)
Buffer11::BufferStorage *Buffer11::getBufferStorage(BufferUsage usage)
{
ASSERT(0 <= usage && usage < BUFFER_USAGE_COUNT);
BufferStorage *&newStorage = mBufferStorages[usage];
......@@ -789,25 +686,19 @@ gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getBufferStorage(BufferUs
// resize buffer
if (newStorage->getSize() < mSize)
{
auto error = newStorage->resize(mSize, true);
if (error.isError())
if (newStorage->resize(mSize, true).isError())
{
return error;
// Out of memory error
return nullptr;
}
}
auto error = updateBufferStorage(newStorage, 0, mSize);
if (error.isError())
{
return error;
}
updateBufferStorage(newStorage, 0, mSize);
return newStorage;
}
gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getConstantBufferRangeStorage(
GLintptr offset,
GLsizeiptr size)
Buffer11::BufferStorage *Buffer11::getConstantBufferRangeStorage(GLintptr offset, GLsizeiptr size)
{
BufferStorage *newStorage;
......@@ -850,10 +741,10 @@ gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getConstantBufferRangeSto
mConstantBufferRangeStoragesCache.erase(iter);
}
auto error = newStorage->resize(size, false);
if (error.isError())
if (newStorage->resize(size, false).isError())
{
return error;
// Out of memory error
return nullptr;
}
mConstantBufferStorageAdditionalSize += sizeDelta;
......@@ -864,26 +755,14 @@ gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getConstantBufferRangeSto
newStorage->setDataRevision(0);
}
auto error = updateBufferStorage(newStorage, offset, size);
if (error.isError())
{
return error;
}
updateBufferStorage(newStorage, offset, size);
return newStorage;
}
gl::Error Buffer11::updateBufferStorage(BufferStorage *storage,
size_t sourceOffset,
size_t storageSize)
void Buffer11::updateBufferStorage(BufferStorage *storage, size_t sourceOffset, size_t storageSize)
{
auto latestOrError = getLatestBufferStorage();
if (latestOrError.isError())
{
return latestOrError.getError();
}
BufferStorage *latestBuffer = latestOrError.getResult();
BufferStorage *latestBuffer = getLatestBufferStorage();
if (latestBuffer && latestBuffer->getDataRevision() > storage->getDataRevision())
{
// Copy through a staging buffer if we're copying from or to a non-staging, mappable
......@@ -893,41 +772,25 @@ gl::Error Buffer11::updateBufferStorage(BufferStorage *storage,
storage->getUsage() != BUFFER_USAGE_STAGING &&
(!latestBuffer->isMappable() || !storage->isMappable()))
{
auto stagingOrError = getStagingStorage();
if (stagingOrError.isError())
{
return stagingOrError.getError();
}
NativeStorage *stagingBuffer = stagingOrError.getResult();
NativeStorage *stagingBuffer = getStagingStorage();
auto resultOrError =
stagingBuffer->copyFromStorage(latestBuffer, 0, latestBuffer->getSize(), 0);
if (resultOrError.isError())
{
return resultOrError.getError();
}
stagingBuffer->copyFromStorage(latestBuffer, 0, latestBuffer->getSize(), 0);
stagingBuffer->setDataRevision(latestBuffer->getDataRevision());
latestBuffer = stagingBuffer;
}
auto resultOrError = storage->copyFromStorage(latestBuffer, sourceOffset, storageSize, 0);
if (resultOrError.isError())
{
return resultOrError.getError();
}
// If the D3D buffer has been recreated, we should update our serial.
if (resultOrError.getResult() == CopyResult::RECREATED)
// if copyFromStorage returns true, the D3D buffer has been recreated
// and we should update our serial
if (storage->copyFromStorage(latestBuffer, sourceOffset, storageSize, 0))
{
updateSerial();
}
storage->setDataRevision(latestBuffer->getDataRevision());
}
return gl::Error(GL_NO_ERROR);
}
gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getLatestBufferStorage() const
Buffer11::BufferStorage *Buffer11::getLatestBufferStorage() const
{
// Even though we iterate over all the direct buffers, it is expected that only
// 1 or 2 will be present.
......@@ -945,36 +808,40 @@ gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getLatestBufferStorage()
// resize buffer
if (latestStorage && latestStorage->getSize() < mSize)
{
auto error = latestStorage->resize(mSize, true);
if (error.isError())
if (latestStorage->resize(mSize, true).isError())
{
return error;
// Out of memory error
return nullptr;
}
}
return latestStorage;
}
gl::ErrorOrResult<Buffer11::NativeStorage *> Buffer11::getStagingStorage()
Buffer11::NativeStorage *Buffer11::getStagingStorage()
{
auto stagingOrError = getBufferStorage(BUFFER_USAGE_STAGING);
if (stagingOrError.isError())
BufferStorage *stagingStorage = getBufferStorage(BUFFER_USAGE_STAGING);
if (!stagingStorage)
{
return stagingOrError.getError();
// Out-of-memory
return nullptr;
}
return GetAs<NativeStorage>(stagingOrError.getResult());
return GetAs<NativeStorage>(stagingStorage);
}
gl::ErrorOrResult<Buffer11::PackStorage *> Buffer11::getPackStorage()
Buffer11::PackStorage *Buffer11::getPackStorage()
{
auto packOrError = getBufferStorage(BUFFER_USAGE_PIXEL_PACK);
if (packOrError.isError())
BufferStorage *packStorage = getBufferStorage(BUFFER_USAGE_PIXEL_PACK);
if (!packStorage)
{
return packOrError.getError();
// Out-of-memory
return nullptr;
}
return GetAs<PackStorage>(packOrError.getResult());
return GetAs<PackStorage>(packStorage);
}
bool Buffer11::supportsDirectBinding() const
......@@ -994,11 +861,10 @@ gl::Error Buffer11::BufferStorage::setData(const uint8_t *data, size_t offset, s
{
ASSERT(isMappable());
uint8_t *writePointer = nullptr;
gl::Error error = map(offset, size, GL_MAP_WRITE_BIT, &writePointer);
if (error.isError())
uint8_t *writePointer = map(offset, size, GL_MAP_WRITE_BIT);
if (!writePointer)
{
return error;
return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal buffer.");
}
memcpy(writePointer, data, size);
......@@ -1019,10 +885,10 @@ Buffer11::NativeStorage::~NativeStorage()
}
// Returns true if it recreates the direct buffer
gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
bool Buffer11::NativeStorage::copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
{
ID3D11DeviceContext *context = mRenderer->getDeviceContext();
......@@ -1041,12 +907,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto
{
ASSERT(source->isMappable());
uint8_t *sourcePointer = nullptr;
gl::Error error = source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourcePointer);
if (error.isError())
{
return error;
}
uint8_t *sourcePointer = source->map(sourceOffset, size, GL_MAP_READ_BIT);
D3D11_MAPPED_SUBRESOURCE mappedResource;
HRESULT hr = context->Map(mNativeStorage, 0, D3D11_MAP_WRITE, 0, &mappedResource);
......@@ -1054,9 +915,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto
if (FAILED(hr))
{
source->unmap();
return gl::Error(
GL_OUT_OF_MEMORY,
"Failed to map native storage in Buffer11::NativeStorage::copyFromStorage");
return false;
}
uint8_t *destPointer = static_cast<uint8_t *>(mappedResource.pData) + destOffset;
......@@ -1084,7 +943,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto
0, sourceBuffer, 0, &srcBox);
}
return createBuffer ? CopyResult::RECREATED : CopyResult::NOT_RECREATED;
return createBuffer;
}
gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData)
......@@ -1190,10 +1049,7 @@ void Buffer11::NativeStorage::fillBufferDesc(D3D11_BUFFER_DESC *bufferDesc,
}
}
gl::Error Buffer11::NativeStorage::map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut)
uint8_t *Buffer11::NativeStorage::map(size_t offset, size_t length, GLbitfield access)
{
ASSERT(mUsage == BUFFER_USAGE_STAGING);
......@@ -1206,12 +1062,9 @@ gl::Error Buffer11::NativeStorage::map(size_t offset,
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::Error(GL_OUT_OF_MEMORY,
"Failed to map native storage in Buffer11::NativeStorage::map");
return nullptr;
}
ASSERT(mappedResource.pData);
*mapPointerOut = static_cast<uint8_t *>(mappedResource.pData) + offset;
return gl::Error(GL_NO_ERROR);
return static_cast<uint8_t *>(mappedResource.pData) + offset;
}
void Buffer11::NativeStorage::unmap()
......@@ -1231,74 +1084,32 @@ Buffer11::EmulatedIndexedStorage::~EmulatedIndexedStorage()
SafeRelease(mNativeStorage);
}
gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeStorage(
SourceIndexData *indexInfo,
const TranslatedAttribute &attribute)
ID3D11Buffer *Buffer11::EmulatedIndexedStorage::getNativeStorage()
{
// If a change in the indices applied from the last draw call is detected, then the emulated
// indexed buffer needs to be invalidated. After invalidation, the change detected flag should
// be cleared to avoid unnecessary recreation of the buffer.
if (mNativeStorage == nullptr || indexInfo->srcIndicesChanged)
{
SafeRelease(mNativeStorage);
// Copy the source index data. This ensures that the lifetime of the indices pointer
// stays with this storage until the next time we invalidate.
size_t indicesDataSize = 0;
switch (indexInfo->srcIndexType)
{
case GL_UNSIGNED_INT:
indicesDataSize = sizeof(GLuint) * indexInfo->srcCount;
break;
case GL_UNSIGNED_SHORT:
indicesDataSize = sizeof(GLushort) * indexInfo->srcCount;
break;
case GL_UNSIGNED_BYTE:
indicesDataSize = sizeof(GLubyte) * indexInfo->srcCount;
break;
default:
indicesDataSize = sizeof(GLushort) * indexInfo->srcCount;
break;
}
if (!mIndicesMemoryBuffer.resize(indicesDataSize))
{
return gl::Error(GL_OUT_OF_MEMORY,
"Error resizing index memory buffer in "
"Buffer11::EmulatedIndexedStorage::getNativeStorage");
}
memcpy(mIndicesMemoryBuffer.data(), indexInfo->srcIndices, indicesDataSize);
indexInfo->srcIndicesChanged = false;
}
if (!mNativeStorage)
{
// Expand the memory storage upon request and cache the results.
unsigned int expandedDataSize =
static_cast<unsigned int>((indexInfo->srcCount * attribute.stride) + attribute.offset);
static_cast<unsigned int>((mIndexInfo.srcCount * mAttributeStride) + mAttributeOffset);
MemoryBuffer expandedData;
if (!expandedData.resize(expandedDataSize))
{
return gl::Error(
GL_OUT_OF_MEMORY,
"Error resizing buffer in Buffer11::EmulatedIndexedStorage::getNativeStorage");
return nullptr;
}
// Clear the contents of the allocated buffer
ZeroMemory(expandedData.data(), expandedDataSize);
uint8_t *curr = expandedData.data();
const uint8_t *ptr = static_cast<const uint8_t *>(indexInfo->srcIndices);
const uint8_t *ptr = static_cast<const uint8_t *>(mIndexInfo.srcIndices);
// Ensure that we start in the correct place for the emulated data copy operation to
// maintain offset behaviors.
curr += attribute.offset;
curr += mAttributeOffset;
ReadIndexValueFunction readIndexValue = ReadIndexValueFromIndices<GLushort>;
switch (indexInfo->srcIndexType)
switch (mIndexInfo.srcIndexType)
{
case GL_UNSIGNED_INT:
readIndexValue = ReadIndexValueFromIndices<GLuint>;
......@@ -1312,11 +1123,11 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
}
// Iterate over the cached index data and copy entries indicated into the emulated buffer.
for (GLuint i = 0; i < indexInfo->srcCount; i++)
for (GLuint i = 0; i < mIndexInfo.srcCount; i++)
{
GLuint idx = readIndexValue(ptr, i);
memcpy(curr, mMemoryBuffer.data() + (attribute.stride * idx), attribute.stride);
curr += attribute.stride;
memcpy(curr, mMemoryBuffer.data() + (mAttributeStride * idx), mAttributeStride);
curr += mAttributeStride;
}
// Finally, initialize the emulated indexed native storage object with the newly copied data
......@@ -1336,8 +1147,8 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
HRESULT result = device->CreateBuffer(&bufferDesc, &subResourceData, &mNativeStorage);
if (FAILED(result))
{
return gl::Error(GL_OUT_OF_MEMORY, "Could not create emulated index data buffer: %08lX",
result);
ERR("Could not create emulated index data buffer: %08lX", result);
return nullptr;
}
d3d11::SetDebugName(mNativeStorage, "Buffer11::EmulatedIndexedStorage");
}
......@@ -1345,23 +1156,67 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
return mNativeStorage;
}
gl::ErrorOrResult<CopyResult> Buffer11::EmulatedIndexedStorage::copyFromStorage(
BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
bool Buffer11::EmulatedIndexedStorage::update(SourceIndexData *indexInfo,
const TranslatedAttribute *attribute)
{
ASSERT(source->isMappable());
uint8_t *sourceData = nullptr;
gl::Error error = source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData);
if (error.isError())
// If a change in the indices applied from the last draw call is detected, then the emulated
// indexed buffer needs to be invalidated. After invalidation, the change detected flag should
// be cleared to avoid unnecessary recreation of the buffer.
if (mNativeStorage == nullptr || indexInfo->srcIndicesChanged)
{
return error;
SafeRelease(mNativeStorage);
// Copy attribute offset and stride information
mAttributeStride = attribute->stride;
mAttributeOffset = attribute->offset;
// Copy the source index data. This ensures that the lifetime of the indices pointer
// stays with this storage until the next time we invalidate.
size_t indicesDataSize = 0;
switch (indexInfo->srcIndexType)
{
case GL_UNSIGNED_INT:
indicesDataSize = sizeof(GLuint) * indexInfo->srcCount;
break;
case GL_UNSIGNED_SHORT:
indicesDataSize = sizeof(GLushort) * indexInfo->srcCount;
break;
case GL_UNSIGNED_BYTE:
indicesDataSize = sizeof(GLubyte) * indexInfo->srcCount;
break;
default:
indicesDataSize = sizeof(GLushort) * indexInfo->srcCount;
break;
}
if (!mIndicesMemoryBuffer.resize(indicesDataSize))
{
return false;
}
memcpy(mIndicesMemoryBuffer.data(), indexInfo->srcIndices, indicesDataSize);
// Copy the source index data description and update the srcIndices pointer to point
// to our cached index data.
mIndexInfo = *indexInfo;
mIndexInfo.srcIndices = mIndicesMemoryBuffer.data();
indexInfo->srcIndicesChanged = false;
}
return true;
}
bool Buffer11::EmulatedIndexedStorage::copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
{
ASSERT(source->isMappable());
const uint8_t *sourceData = source->map(sourceOffset, size, GL_MAP_READ_BIT);
ASSERT(destOffset + size <= mMemoryBuffer.size());
memcpy(mMemoryBuffer.data() + destOffset, sourceData, size);
source->unmap();
return CopyResult::RECREATED;
return true;
}
gl::Error Buffer11::EmulatedIndexedStorage::resize(size_t size, bool preserveData)
......@@ -1378,14 +1233,10 @@ gl::Error Buffer11::EmulatedIndexedStorage::resize(size_t size, bool preserveDat
return gl::Error(GL_NO_ERROR);
}
gl::Error Buffer11::EmulatedIndexedStorage::map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut)
uint8_t *Buffer11::EmulatedIndexedStorage::map(size_t offset, size_t length, GLbitfield access)
{
ASSERT(!mMemoryBuffer.empty() && offset + length <= mMemoryBuffer.size());
*mapPointerOut = mMemoryBuffer.data() + offset;
return gl::Error(GL_NO_ERROR);
return mMemoryBuffer.data() + offset;
}
void Buffer11::EmulatedIndexedStorage::unmap()
......@@ -1402,15 +1253,15 @@ Buffer11::PackStorage::~PackStorage()
{
}
gl::ErrorOrResult<CopyResult> Buffer11::PackStorage::copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
bool Buffer11::PackStorage::copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
{
// We copy through a staging buffer when drawing with a pack buffer,
// or for other cases where we access the pack buffer
UNREACHABLE();
return CopyResult::NOT_RECREATED;
return false;
}
gl::Error Buffer11::PackStorage::resize(size_t size, bool preserveData)
......@@ -1427,10 +1278,7 @@ gl::Error Buffer11::PackStorage::resize(size_t size, bool preserveData)
return gl::Error(GL_NO_ERROR);
}
gl::Error Buffer11::PackStorage::map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut)
uint8_t *Buffer11::PackStorage::map(size_t offset, size_t length, GLbitfield access)
{
ASSERT(offset + length <= getSize());
// TODO: fast path
......@@ -1441,13 +1289,12 @@ gl::Error Buffer11::PackStorage::map(size_t offset,
gl::Error error = flushQueuedPackCommand();
if (error.isError())
{
return error;
return nullptr;
}
mDataModified = (mDataModified || (access & GL_MAP_WRITE_BIT) != 0);
*mapPointerOut = mMemoryBuffer.data() + offset;
return gl::Error(GL_NO_ERROR);
return mMemoryBuffer.data() + offset;
}
void Buffer11::PackStorage::unmap()
......@@ -1542,22 +1389,17 @@ Buffer11::SystemMemoryStorage::SystemMemoryStorage(Renderer11 *renderer)
{
}
gl::ErrorOrResult<CopyResult> Buffer11::SystemMemoryStorage::copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
bool Buffer11::SystemMemoryStorage::copyFromStorage(BufferStorage *source,
size_t sourceOffset,
size_t size,
size_t destOffset)
{
ASSERT(source->isMappable());
uint8_t *sourceData = nullptr;
gl::Error error = source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData);
if (error.isError())
{
return error;
}
const uint8_t *sourceData = source->map(sourceOffset, size, GL_MAP_READ_BIT);
ASSERT(destOffset + size <= mSystemCopy.size());
memcpy(mSystemCopy.data() + destOffset, sourceData, size);
source->unmap();
return CopyResult::RECREATED;
return true;
}
gl::Error Buffer11::SystemMemoryStorage::resize(size_t size, bool preserveData)
......@@ -1574,18 +1416,14 @@ gl::Error Buffer11::SystemMemoryStorage::resize(size_t size, bool preserveData)
return gl::Error(GL_NO_ERROR);
}
gl::Error Buffer11::SystemMemoryStorage::map(size_t offset,
size_t length,
GLbitfield access,
uint8_t **mapPointerOut)
uint8_t *Buffer11::SystemMemoryStorage::map(size_t offset, size_t length, GLbitfield access)
{
ASSERT(!mSystemCopy.empty() && offset + length <= mSystemCopy.size());
*mapPointerOut = mSystemCopy.data() + offset;
return gl::Error(GL_NO_ERROR);
return mSystemCopy.data() + offset;
}
void Buffer11::SystemMemoryStorage::unmap()
{
// No-op
}
} // namespace rx
}
src/libANGLE/renderer/d3d/d3d11/Buffer11.h
......@@ -62,13 +62,11 @@ class Buffer11 : public BufferD3D
Buffer11(Renderer11 *renderer);
virtual ~Buffer11();
gl::ErrorOrResult<ID3D11Buffer *> getBuffer(BufferUsage usage);
gl::ErrorOrResult<ID3D11Buffer *> getEmulatedIndexedBuffer(
SourceIndexData *indexInfo,
const TranslatedAttribute &attribute);
gl::ErrorOrResult<ID3D11Buffer *> getConstantBufferRange(GLintptr offset, GLsizeiptr size);
gl::ErrorOrResult<ID3D11ShaderResourceView *> getSRV(DXGI_FORMAT srvFormat);
bool isMapped() const { return mMappedStorage != nullptr; }
ID3D11Buffer *getBuffer(BufferUsage usage);
ID3D11Buffer *getEmulatedIndexedBuffer(SourceIndexData *indexInfo, const TranslatedAttribute *attribute);
ID3D11Buffer *getConstantBufferRange(GLintptr offset, GLsizeiptr size);
ID3D11ShaderResourceView *getSRV(DXGI_FORMAT srvFormat);
bool isMapped() const { return mMappedStorage != NULL; }
gl::Error packPixels(const gl::FramebufferAttachment &readAttachment,
const PackPixelsParams &params);
size_t getTotalCPUBufferMemoryBytes() const;
......@@ -85,7 +83,7 @@ class Buffer11 : public BufferD3D
virtual gl::Error map(GLenum access, GLvoid **mapPtr);
virtual gl::Error mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr);
virtual gl::Error unmap(GLboolean *result);
virtual gl::Error markTransformFeedbackUsage();
virtual void markTransformFeedbackUsage();
private:
class BufferStorage;
......@@ -122,19 +120,20 @@ class Buffer11 : public BufferD3D
unsigned int mReadUsageCount;
gl::Error markBufferUsage();
gl::ErrorOrResult<NativeStorage *> getStagingStorage();
gl::ErrorOrResult<PackStorage *> getPackStorage();
gl::ErrorOrResult<SystemMemoryStorage *> getSystemMemoryStorage();
void markBufferUsage();
NativeStorage *getStagingStorage();
PackStorage *getPackStorage();
gl::Error getSystemMemoryStorage(SystemMemoryStorage **storageOut);
gl::Error updateBufferStorage(BufferStorage *storage, size_t sourceOffset, size_t storageSize);
gl::ErrorOrResult<BufferStorage *> getBufferStorage(BufferUsage usage);
gl::ErrorOrResult<BufferStorage *> getLatestBufferStorage() const;
void updateBufferStorage(BufferStorage *storage, size_t sourceOffset, size_t storageSize);
BufferStorage *getBufferStorage(BufferUsage usage);
BufferStorage *getLatestBufferStorage() const;
gl::ErrorOrResult<BufferStorage *> getConstantBufferRangeStorage(GLintptr offset,
GLsizeiptr size);
BufferStorage *getConstantBufferRangeStorage(GLintptr offset, GLsizeiptr size);
void invalidateEmulatedIndexedBuffer();
};
} // namespace rx
}
#endif // LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_
src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp
......@@ -293,23 +293,11 @@ gl::Error InputLayoutCache::applyVertexBuffers(
indexInfo->srcIndexData.srcIndices = bufferData + offset;
}
auto bufferOrError =
bufferStorage->getEmulatedIndexedBuffer(&indexInfo->srcIndexData, attrib);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
buffer = bufferOrError.getResult();
buffer = bufferStorage->getEmulatedIndexedBuffer(&indexInfo->srcIndexData, &attrib);
}
else
{
auto bufferOrError =
bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
buffer = bufferOrError.getResult();
buffer = bufferStorage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
}
vertexStride = attrib.stride;
......
src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp
......@@ -208,23 +208,18 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
DXGI_FORMAT srvFormat = sourceFormatInfo.formatSet->srvFormat;
ASSERT(srvFormat != DXGI_FORMAT_UNKNOWN);
Buffer11 *bufferStorage11 = GetAs<Buffer11>(sourceBuffer.getImplementation());
auto srvOrError = bufferStorage11->getSRV(srvFormat);
if (srvOrError.isError())
{
return srvOrError.getError();
}
ID3D11ShaderResourceView *bufferSRV = srvOrError.getResult();
ASSERT(bufferSRV != nullptr);
ID3D11ShaderResourceView *bufferSRV = bufferStorage11->getSRV(srvFormat);
ASSERT(bufferSRV != NULL);
ID3D11RenderTargetView *textureRTV = GetAs<RenderTarget11>(destRenderTarget)->getRenderTargetView();
ASSERT(textureRTV != nullptr);
ASSERT(textureRTV != NULL);
CopyShaderParams shaderParams;
setBufferToTextureCopyParams(destArea, destSize, sourceFormat, unpack, offset, &shaderParams);
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
ID3D11Buffer *nullBuffer = nullptr;
ID3D11Buffer *nullBuffer = NULL;
UINT zero = 0;
// Are we doing a 2D or 3D copy?
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -1288,22 +1288,11 @@ gl::Error Renderer11::setUniformBuffers(const gl::Data &data,
if (mRenderer11DeviceCaps.supportsConstantBufferOffsets)
{
auto bufferOrError = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
constantBuffer = bufferOrError.getResult();
constantBuffer = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
}
else
{
auto bufferOrError =
bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
constantBuffer = bufferOrError.getResult();
constantBuffer = bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
}
if (!constantBuffer)
......@@ -1360,22 +1349,11 @@ gl::Error Renderer11::setUniformBuffers(const gl::Data &data,
if (mRenderer11DeviceCaps.supportsConstantBufferOffsets)
{
auto bufferOrError = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
constantBuffer = bufferOrError.getResult();
constantBuffer = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM);
}
else
{
auto bufferOrError =
bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
constantBuffer = bufferOrError.getResult();
constantBuffer = bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize);
}
if (!constantBuffer)
......@@ -1564,12 +1542,7 @@ gl::Error Renderer11::applyIndexBuffer(const gl::Data &data,
if (indexInfo->storage)
{
Buffer11 *storage = GetAs<Buffer11>(indexInfo->storage);
auto indexOrError = storage->getBuffer(BUFFER_USAGE_INDEX);
if (indexOrError.isError())
{
return indexOrError.getError();
}
buffer = indexOrError.getResult();
buffer = storage->getBuffer(BUFFER_USAGE_INDEX);
}
else
{
......@@ -1591,7 +1564,7 @@ gl::Error Renderer11::applyIndexBuffer(const gl::Data &data,
return gl::Error(GL_NO_ERROR);
}
gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
void Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
{
size_t numXFBBindings = 0;
bool requiresUpdate = false;
......@@ -1606,16 +1579,11 @@ gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
{
const OffsetBindingPointer<gl::Buffer> &binding = transformFeedback->getIndexedBuffer(i);
ID3D11Buffer *d3dBuffer = nullptr;
ID3D11Buffer *d3dBuffer = NULL;
if (binding.get() != nullptr)
{
Buffer11 *storage = GetImplAs<Buffer11>(binding.get());
auto bufferOrError = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
d3dBuffer = bufferOrError.getResult();
d3dBuffer = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
}
// TODO: mAppliedTFBuffers and friends should also be kept in a vector.
......@@ -1635,12 +1603,7 @@ gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
if (binding.get() != nullptr)
{
Buffer11 *storage = GetImplAs<Buffer11>(binding.get());
auto bufferOrError = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
if (bufferOrError.isError())
{
return bufferOrError.getError();
}
ID3D11Buffer *d3dBuffer = bufferOrError.getResult();
ID3D11Buffer *d3dBuffer = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
mCurrentD3DOffsets[i] = (mAppliedTFBuffers[i] != d3dBuffer || mAppliedTFOffsets[i] != binding.getOffset()) ?
static_cast<UINT>(binding.getOffset()) : -1;
......@@ -1648,7 +1611,7 @@ gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
}
else
{
mAppliedTFBuffers[i] = nullptr;
mAppliedTFBuffers[i] = NULL;
mCurrentD3DOffsets[i] = 0;
}
mAppliedTFOffsets[i] = binding.getOffset();
......@@ -1659,8 +1622,6 @@ gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::State &state)
mDeviceContext->SOSetTargets(static_cast<unsigned int>(numXFBBindings), mAppliedTFBuffers,
mCurrentD3DOffsets);
}
return gl::Error(GL_NO_ERROR);
}
gl::Error Renderer11::drawArraysImpl(const gl::Data &data,
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.h
......@@ -148,7 +148,7 @@ class Renderer11 : public RendererD3D
GLenum mode,
GLenum type,
TranslatedIndexData *indexInfo) override;
gl::Error applyTransformFeedbackBuffers(const gl::State &state) override;
void applyTransformFeedbackBuffers(const gl::State &state) override;
// lost device
bool testDeviceLost() override;
......
src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp
......@@ -104,10 +104,9 @@ gl::Error Buffer9::unmap(GLboolean *result)
return gl::Error(GL_INVALID_OPERATION);
}
gl::Error Buffer9::markTransformFeedbackUsage()
void Buffer9::markTransformFeedbackUsage()
{
UNREACHABLE();
return gl::Error(GL_INVALID_OPERATION);
}
} // namespace rx
}
src/libANGLE/renderer/d3d/d3d9/Buffer9.h
......@@ -35,13 +35,13 @@ class Buffer9 : public BufferD3D
virtual gl::Error map(GLenum access, GLvoid **mapPtr);
virtual gl::Error mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr);
virtual gl::Error unmap(GLboolean *result);
virtual gl::Error markTransformFeedbackUsage();
virtual void markTransformFeedbackUsage();
private:
MemoryBuffer mMemory;
size_t mSize;
};
} // namespace rx
}
#endif // LIBANGLE_RENDERER_D3D_D3D9_BUFFER9_H_
src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
......@@ -1218,10 +1218,9 @@ gl::Error Renderer9::applyIndexBuffer(const gl::Data &data,
return gl::Error(GL_NO_ERROR);
}
gl::Error Renderer9::applyTransformFeedbackBuffers(const gl::State &state)
void Renderer9::applyTransformFeedbackBuffers(const gl::State& state)
{
ASSERT(!state.isTransformFeedbackActiveUnpaused());
return gl::Error(GL_NO_ERROR);
}
gl::Error Renderer9::drawArraysImpl(const gl::Data &data,
......
src/libANGLE/renderer/d3d/d3d9/Renderer9.h
......@@ -134,7 +134,7 @@ class Renderer9 : public RendererD3D
GLenum type,
TranslatedIndexData *indexInfo) override;
gl::Error applyTransformFeedbackBuffers(const gl::State &state) override;
void applyTransformFeedbackBuffers(const gl::State &state) override;
gl::Error clear(const ClearParameters &clearParams,
const gl::FramebufferAttachment *colorBuffer,
......
src/tests/gl_tests/D3D11EmulatedIndexedBufferTest.cpp
......@@ -107,10 +107,9 @@ class D3D11EmulatedIndexedBufferTest : public ANGLETest
void emulateAndCompare(rx::SourceIndexData *srcData)
{
auto bufferOrError = mSourceBuffer->getEmulatedIndexedBuffer(srcData, mTranslatedAttribute);
ASSERT_FALSE(bufferOrError.isError());
ID3D11Buffer *emulatedBuffer = bufferOrError.getResult();
ID3D11Buffer* emulatedBuffer = mSourceBuffer->getEmulatedIndexedBuffer(srcData, &mTranslatedAttribute);
ASSERT_TRUE(emulatedBuffer != nullptr);
compareContents(emulatedBuffer);
}
......
src/tests/perf_tests/IndexDataManagerTest.cpp
......@@ -99,7 +99,7 @@ class MockBufferD3D : public rx::BufferD3D
MOCK_METHOD1(unmap, gl::Error(GLboolean *));
// BufferD3D
MOCK_METHOD0(markTransformFeedbackUsage, gl::Error());
MOCK_METHOD0(markTransformFeedbackUsage, void());
// inlined for speed
bool supportsDirectBinding() const override { return false; }
......
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