blob: bb2f9fdaedc3286373ed1aed4f13e7521ecf63f3 [file] [log] [blame]
//
// Copyright (c) 2002-2014 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
{
BufferState::BufferState()
: mLabel(),
mUsage(GL_STATIC_DRAW),
mSize(0),
mAccessFlags(0),
mAccess(GL_WRITE_ONLY_OES),
mMapped(GL_FALSE),
mMapPointer(nullptr),
mMapOffset(0),
mMapLength(0)
{
}
BufferState::~BufferState()
{
}
Buffer::Buffer(rx::GLImplFactory *factory, GLuint id)
: RefCountObject(id), mImpl(factory->createBuffer(mState))
{
}
Buffer::~Buffer()
{
SafeDelete(mImpl);
}
void Buffer::destroy(const Context *context)
{
// In tests, mImpl might be null.
if (mImpl)
mImpl->destroy(rx::SafeGetImpl(context));
}
void Buffer::setLabel(const std::string &label)
{
mState.mLabel = label;
}
const std::string &Buffer::getLabel() const
{
return mState.mLabel;
}
Error Buffer::bufferData(const Context *context,
GLenum target,
const void *data,
GLsizeiptr size,
GLenum usage)
{
const void *dataForImpl = data;
// If we are using robust resource init, make sure the buffer starts cleared.
// TODO(jmadill): Investigate lazier clearing.
if (context && context->getGLState().isRobustResourceInitEnabled() && data == nullptr)
{
angle::MemoryBuffer *scratchBuffer = nullptr;
ANGLE_TRY(context->getScratchBuffer(static_cast<size_t>(size), &scratchBuffer));
std::fill(scratchBuffer->data(), scratchBuffer->data() + size, static_cast<uint8_t>(0));
dataForImpl = scratchBuffer->data();
}
ANGLE_TRY(mImpl->setData(rx::SafeGetImpl(context), target, dataForImpl, size, usage));
mIndexRangeCache.clear();
mState.mUsage = usage;
mState.mSize = size;
return NoError();
}
Error Buffer::bufferSubData(const Context *context,
GLenum target,
const void *data,
GLsizeiptr size,
GLintptr offset)
{
ANGLE_TRY(mImpl->setSubData(rx::SafeGetImpl(context), target, data, size, offset));
mIndexRangeCache.invalidateRange(static_cast<unsigned int>(offset), static_cast<unsigned int>(size));
return NoError();
}
Error Buffer::copyBufferSubData(const Context *context,
Buffer *source,
GLintptr sourceOffset,
GLintptr destOffset,
GLsizeiptr size)
{
ANGLE_TRY(mImpl->copySubData(rx::SafeGetImpl(context), source->getImplementation(),
sourceOffset, destOffset, size));
mIndexRangeCache.invalidateRange(static_cast<unsigned int>(destOffset), static_cast<unsigned int>(size));
return NoError();
}
Error Buffer::map(const Context *context, GLenum access)
{
ASSERT(!mState.mMapped);
mState.mMapPointer = nullptr;
ANGLE_TRY(mImpl->map(rx::SafeGetImpl(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();
return NoError();
}
Error 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(rx::SafeGetImpl(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));
}
return NoError();
}
Error Buffer::unmap(const Context *context, GLboolean *result)
{
ASSERT(mState.mMapped);
*result = GL_FALSE;
ANGLE_TRY(mImpl->unmap(rx::SafeGetImpl(context), result));
mState.mMapped = GL_FALSE;
mState.mMapPointer = nullptr;
mState.mMapOffset = 0;
mState.mMapLength = 0;
mState.mAccess = GL_WRITE_ONLY_OES;
mState.mAccessFlags = 0;
return NoError();
}
void Buffer::onTransformFeedback()
{
mIndexRangeCache.clear();
}
void Buffer::onPixelUnpack()
{
mIndexRangeCache.clear();
}
Error Buffer::getIndexRange(GLenum type,
size_t offset,
size_t count,
bool primitiveRestartEnabled,
IndexRange *outRange) const
{
if (mIndexRangeCache.findRange(type, offset, count, primitiveRestartEnabled, outRange))
{
return NoError();
}
ANGLE_TRY(mImpl->getIndexRange(type, offset, count, primitiveRestartEnabled, outRange));
mIndexRangeCache.addRange(type, offset, count, primitiveRestartEnabled, *outRange);
return NoError();
}
} // namespace gl