Source code
Revision control
Copy as Markdown
Other Tools
//
// Copyright 2002 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.
//
// Buffer.cpp: Implements the gl::Buffer class, representing storage of vertex and/or
// index data. Implements GL buffer objects and related functionality.
// [OpenGL ES 2.0.24] section 2.9 page 21.
#include "libANGLE/Buffer.h"
#include "libANGLE/Context.h"
#include "libANGLE/renderer/BufferImpl.h"
#include "libANGLE/renderer/GLImplFactory.h"
namespace gl
{
namespace
{
constexpr angle::SubjectIndex kImplementationSubjectIndex = 0;
constexpr size_t kInvalidContentsObserverIndex = std::numeric_limits<size_t>::max();
} // anonymous namespace
BufferState::BufferState()
: mLabel(),
mUsage(BufferUsage::StaticDraw),
mSize(0),
mAccessFlags(0),
mAccess(GL_WRITE_ONLY_OES),
mMapped(GL_FALSE),
mMapPointer(nullptr),
mMapOffset(0),
mMapLength(0),
mBindingCount(0),
mTransformFeedbackIndexedBindingCount(0),
mTransformFeedbackGenericBindingCount(0),
mImmutable(GL_FALSE),
mStorageExtUsageFlags(0),
mExternal(GL_FALSE)
{}
BufferState::~BufferState() {}
Buffer::Buffer(rx::GLImplFactory *factory, BufferID id)
: RefCountObject(factory->generateSerial(), id),
mImpl(factory->createBuffer(mState)),
mImplObserver(this, kImplementationSubjectIndex)
{
mImplObserver.bind(mImpl);
}
Buffer::~Buffer()
{
SafeDelete(mImpl);
}
void Buffer::onDestroy(const Context *context)
{
// In tests, mImpl might be null.
if (mImpl)
mImpl->destroy(context);
}
angle::Result Buffer::setLabel(const Context *context, const std::string &label)
{
mState.mLabel = label;
if (mImpl)
{
return mImpl->onLabelUpdate(context);
}
return angle::Result::Continue;
}
const std::string &Buffer::getLabel() const
{
return mState.mLabel;
}
angle::Result Buffer::bufferStorageExternal(Context *context,
BufferBinding target,
GLsizeiptr size,
GLeglClientBufferEXT clientBuffer,
GLbitfield flags)
{
return bufferExternalDataImpl(context, target, clientBuffer, size, flags);
}
angle::Result Buffer::bufferStorage(Context *context,
BufferBinding target,
GLsizeiptr size,
const void *data,
GLbitfield flags)
{
return bufferDataImpl(context, target, data, size, BufferUsage::InvalidEnum, flags);
}
angle::Result Buffer::bufferData(Context *context,
BufferBinding target,
const void *data,
GLsizeiptr size,
BufferUsage usage)
{
GLbitfield flags = (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_DYNAMIC_STORAGE_BIT_EXT);
return bufferDataImpl(context, target, data, size, usage, flags);
}
angle::Result Buffer::bufferDataImpl(Context *context,
BufferBinding target,
const void *data,
GLsizeiptr size,
BufferUsage usage,
GLbitfield flags)
{
const void *dataForImpl = data;
if (mState.isMapped())
{
// Per the OpenGL ES 3.0 spec, buffers are implicity unmapped when a call to
// BufferData happens on a mapped buffer:
//
// If any portion of the buffer object is mapped in the current context or any context
// current to another thread, it is as though UnmapBuffer (see section 2.10.3) is
// executed in each such context prior to deleting the existing data store.
//
GLboolean dontCare = GL_FALSE;
ANGLE_TRY(unmap(context, &dontCare));
}
// If we are using robust resource init, make sure the buffer starts cleared.
// Note: the Context is checked for nullptr because of some testing code.
// TODO(jmadill): Investigate lazier clearing.
if (context && context->isRobustResourceInitEnabled() && !data && size > 0)
{
angle::MemoryBuffer *scratchBuffer = nullptr;
ANGLE_CHECK_GL_ALLOC(
context, context->getZeroFilledBuffer(static_cast<size_t>(size), &scratchBuffer));
dataForImpl = scratchBuffer->data();
}
if (mImpl->setDataWithUsageFlags(context, target, nullptr, dataForImpl, size, usage, flags) ==
angle::Result::Stop)
{
// If setData fails, the buffer contents are undefined. Set a zero size to indicate that.
mIndexRangeCache.clear();
mState.mSize = 0;
// Notify when storage changes.
onStateChange(angle::SubjectMessage::SubjectChanged);
return angle::Result::Stop;
}
bool wholeBuffer = size == mState.mSize;
mIndexRangeCache.clear();
mState.mUsage = usage;
mState.mSize = size;
mState.mImmutable = (usage == BufferUsage::InvalidEnum);
mState.mStorageExtUsageFlags = flags;
// Notify when storage changes.
if (wholeBuffer)
{
onContentsChange();
}
else
{
onStateChange(angle::SubjectMessage::SubjectChanged);
}
return angle::Result::Continue;
}
angle::Result Buffer::bufferExternalDataImpl(Context *context,
BufferBinding target,
GLeglClientBufferEXT clientBuffer,
GLsizeiptr size,
GLbitfield flags)
{
if (mState.isMapped())
{
// Per the OpenGL ES 3.0 spec, buffers are implicitly unmapped when a call to
// BufferData happens on a mapped buffer:
//
// If any portion of the buffer object is mapped in the current context or any context
// current to another thread, it is as though UnmapBuffer (see section 2.10.3) is
// executed in each such context prior to deleting the existing data store.
//
GLboolean dontCare = GL_FALSE;
ANGLE_TRY(unmap(context, &dontCare));
}
if (mImpl->setDataWithUsageFlags(context, target, clientBuffer, nullptr, size,
BufferUsage::InvalidEnum, flags) == angle::Result::Stop)
{
// If setData fails, the buffer contents are undefined. Set a zero size to indicate that.
mIndexRangeCache.clear();
mState.mSize = 0;
// Notify when storage changes.
onStateChange(angle::SubjectMessage::SubjectChanged);
return angle::Result::Stop;
}
mIndexRangeCache.clear();
mState.mUsage = BufferUsage::InvalidEnum;
mState.mSize = size;
mState.mImmutable = GL_TRUE;
mState.mStorageExtUsageFlags = flags;
mState.mExternal = GL_TRUE;
// Notify when storage changes.
onStateChange(angle::SubjectMessage::SubjectChanged);
return angle::Result::Continue;
}
angle::Result Buffer::bufferSubData(const Context *context,
BufferBinding target,
const void *data,
GLsizeiptr size,
GLintptr offset)
{
ANGLE_TRY(mImpl->setSubData(context, target, data, size, offset));
mIndexRangeCache.invalidateRange(static_cast<unsigned int>(offset),
static_cast<unsigned int>(size));
// Notify when data changes.
onContentsChange();
return angle::Result::Continue;
}
angle::Result Buffer::copyBufferSubData(const Context *context,
Buffer *source,
GLintptr sourceOffset,
GLintptr destOffset,
GLsizeiptr size)
{
ANGLE_TRY(
mImpl->copySubData(context, source->getImplementation(), sourceOffset, destOffset, size));
mIndexRangeCache.invalidateRange(static_cast<unsigned int>(destOffset),
static_cast<unsigned int>(size));
// Notify when data changes.
onContentsChange();
return angle::Result::Continue;
}
angle::Result Buffer::map(const Context *context, GLenum access)
{
ASSERT(!mState.mMapped);
mState.mMapPointer = nullptr;
ANGLE_TRY(mImpl->map(context, access, &mState.mMapPointer));
ASSERT(access == GL_WRITE_ONLY_OES);
mState.mMapped = GL_TRUE;
mState.mMapOffset = 0;
mState.mMapLength = mState.mSize;
mState.mAccess = access;
mState.mAccessFlags = GL_MAP_WRITE_BIT;
mIndexRangeCache.clear();
// Notify when state changes.
onStateChange(angle::SubjectMessage::SubjectMapped);
return angle::Result::Continue;
}
angle::Result Buffer::mapRange(const Context *context,
GLintptr offset,
GLsizeiptr length,
GLbitfield access)
{
ASSERT(!mState.mMapped);
ASSERT(offset + length <= mState.mSize);
mState.mMapPointer = nullptr;
ANGLE_TRY(mImpl->mapRange(context, offset, length, access, &mState.mMapPointer));
mState.mMapped = GL_TRUE;
mState.mMapOffset = static_cast<GLint64>(offset);
mState.mMapLength = static_cast<GLint64>(length);
mState.mAccess = GL_WRITE_ONLY_OES;
mState.mAccessFlags = access;
// The OES_mapbuffer extension states that GL_WRITE_ONLY_OES is the only valid
// value for GL_BUFFER_ACCESS_OES because it was written against ES2. Since there is
// no update for ES3 and the GL_READ_ONLY and GL_READ_WRITE enums don't exist for ES,
// we cannot properly set GL_BUFFER_ACCESS_OES when glMapBufferRange is called.
if ((access & GL_MAP_WRITE_BIT) > 0)
{
mIndexRangeCache.invalidateRange(static_cast<unsigned int>(offset),
static_cast<unsigned int>(length));
}
// Notify when state changes.
onStateChange(angle::SubjectMessage::SubjectMapped);
return angle::Result::Continue;
}
angle::Result Buffer::unmap(const Context *context, GLboolean *result)
{
ASSERT(mState.mMapped);
*result = GL_FALSE;
ANGLE_TRY(mImpl->unmap(context, result));
mState.mMapped = GL_FALSE;
mState.mMapPointer = nullptr;
mState.mMapOffset = 0;
mState.mMapLength = 0;
mState.mAccess = GL_WRITE_ONLY_OES;
mState.mAccessFlags = 0;
// Notify when data changes.
onStateChange(angle::SubjectMessage::SubjectUnmapped);
return angle::Result::Continue;
}
void Buffer::onDataChanged()
{
mIndexRangeCache.clear();
// Notify when data changes.
onContentsChange();
mImpl->onDataChanged();
}
angle::Result Buffer::getIndexRange(const gl::Context *context,
DrawElementsType type,
size_t offset,
size_t count,
bool primitiveRestartEnabled,
IndexRange *outRange) const
{
if (mIndexRangeCache.findRange(type, offset, count, primitiveRestartEnabled, outRange))
{
return angle::Result::Continue;
}
ANGLE_TRY(
mImpl->getIndexRange(context, type, offset, count, primitiveRestartEnabled, outRange));
mIndexRangeCache.addRange(type, offset, count, primitiveRestartEnabled, *outRange);
return angle::Result::Continue;
}
GLint64 Buffer::getMemorySize() const
{
GLint64 implSize = mImpl->getMemorySize();
return implSize > 0 ? implSize : mState.mSize;
}
bool Buffer::isDoubleBoundForTransformFeedback() const
{
return mState.mTransformFeedbackIndexedBindingCount > 1;
}
void Buffer::onTFBindingChanged(const Context *context, bool bound, bool indexed)
{
ASSERT(bound || mState.mBindingCount > 0);
mState.mBindingCount += bound ? 1 : -1;
if (indexed)
{
ASSERT(bound || mState.mTransformFeedbackIndexedBindingCount > 0);
mState.mTransformFeedbackIndexedBindingCount += bound ? 1 : -1;
onStateChange(angle::SubjectMessage::BindingChanged);
}
else
{
mState.mTransformFeedbackGenericBindingCount += bound ? 1 : -1;
}
}
angle::Result Buffer::getSubData(const gl::Context *context,
GLintptr offset,
GLsizeiptr size,
void *outData)
{
return mImpl->getSubData(context, offset, size, outData);
}
void Buffer::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{
// Pass it along!
ASSERT(index == kImplementationSubjectIndex);
ASSERT(message == angle::SubjectMessage::SubjectChanged ||
message == angle::SubjectMessage::InternalMemoryAllocationChanged);
onStateChange(message);
}
size_t Buffer::getContentsObserverIndex(VertexArray *vertexArray, uint32_t bufferIndex) const
{
for (size_t observerIndex = 0; observerIndex < mContentsObservers.size(); ++observerIndex)
{
const ContentsObserver &observer = mContentsObservers[observerIndex];
if (observer.vertexArray == vertexArray && observer.bufferIndex == bufferIndex)
{
return observerIndex;
}
}
return kInvalidContentsObserverIndex;
}
void Buffer::addContentsObserver(VertexArray *vertexArray, uint32_t bufferIndex)
{
if (getContentsObserverIndex(vertexArray, bufferIndex) == kInvalidContentsObserverIndex)
{
mContentsObservers.push_back({vertexArray, bufferIndex});
}
}
void Buffer::removeContentsObserver(VertexArray *vertexArray, uint32_t bufferIndex)
{
size_t foundObserver = getContentsObserverIndex(vertexArray, bufferIndex);
if (foundObserver != kInvalidContentsObserverIndex)
{
size_t lastObserverIndex = mContentsObservers.size() - 1;
if (foundObserver != lastObserverIndex)
{
mContentsObservers[foundObserver] = mContentsObservers[lastObserverIndex];
}
mContentsObservers.pop_back();
}
}
void Buffer::onContentsChange()
{
for (const ContentsObserver &observer : mContentsObservers)
{
observer.vertexArray->onBufferContentsChange(observer.bufferIndex);
}
}
} // namespace gl