chromium/third_party/angle/src/libANGLE/Buffer.cpp

//
// 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 = …;
constexpr size_t kInvalidContentsObserverIndex            = …;
}  // anonymous namespace

BufferState::BufferState()
    : … { … }

BufferState::~BufferState() { … }

Buffer::Buffer(rx::GLImplFactory *factory, BufferID id)
    : … { … }

Buffer::~Buffer()
{ … }

void Buffer::onDestroy(const Context *context)
{ … }

void Buffer::onBind(const Context *context, BufferBinding target)
{ … }

angle::Result Buffer::setLabel(const Context *context, const std::string &label)
{ … }

const std::string &Buffer::getLabel() const
{ … }

angle::Result Buffer::bufferStorageExternal(Context *context,
                                            BufferBinding target,
                                            GLsizeiptr size,
                                            GLeglClientBufferEXT clientBuffer,
                                            GLbitfield flags)
{ … }

angle::Result Buffer::bufferStorage(Context *context,
                                    BufferBinding target,
                                    GLsizeiptr size,
                                    const void *data,
                                    GLbitfield flags)
{ … }

angle::Result Buffer::bufferData(Context *context,
                                 BufferBinding target,
                                 const void *data,
                                 GLsizeiptr size,
                                 BufferUsage usage)
{ … }

angle::Result Buffer::bufferDataImpl(Context *context,
                                     BufferBinding target,
                                     const void *data,
                                     GLsizeiptr size,
                                     BufferUsage usage,
                                     GLbitfield flags)
{ … }

angle::Result Buffer::bufferExternalDataImpl(Context *context,
                                             BufferBinding target,
                                             GLeglClientBufferEXT clientBuffer,
                                             GLsizeiptr size,
                                             GLbitfield flags)
{ … }

angle::Result Buffer::bufferSubData(const Context *context,
                                    BufferBinding target,
                                    const void *data,
                                    GLsizeiptr size,
                                    GLintptr offset)
{ … }

angle::Result Buffer::copyBufferSubData(const Context *context,
                                        Buffer *source,
                                        GLintptr sourceOffset,
                                        GLintptr destOffset,
                                        GLsizeiptr size)
{ … }

angle::Result Buffer::map(const Context *context, GLenum access)
{ … }

angle::Result Buffer::mapRange(const Context *context,
                               GLintptr offset,
                               GLsizeiptr length,
                               GLbitfield access)
{ … }

angle::Result Buffer::unmap(const Context *context, GLboolean *result)
{ … }

void Buffer::onDataChanged()
{ … }

angle::Result Buffer::getIndexRange(const gl::Context *context,
                                    DrawElementsType type,
                                    size_t offset,
                                    size_t count,
                                    bool primitiveRestartEnabled,
                                    IndexRange *outRange) const
{ … }

GLint64 Buffer::getMemorySize() const
{ … }

bool Buffer::isDoubleBoundForTransformFeedback() const
{ … }

void Buffer::onTFBindingChanged(const Context *context, bool bound, bool indexed)
{ … }

angle::Result Buffer::getSubData(const gl::Context *context,
                                 GLintptr offset,
                                 GLsizeiptr size,
                                 void *outData)
{ … }

void Buffer::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{ … }

size_t Buffer::getContentsObserverIndex(void *observer, uint32_t bufferIndex) const
{ … }

void Buffer::addContentsObserver(VertexArray *vertexArray, uint32_t bufferIndex)
{ … }

void Buffer::removeContentsObserverImpl(void *observer, uint32_t bufferIndex)
{ … }

void Buffer::removeContentsObserver(VertexArray *vertexArray, uint32_t bufferIndex)
{ … }

void Buffer::addContentsObserver(Texture *texture)
{ … }

void Buffer::removeContentsObserver(Texture *texture)
{ … }

bool Buffer::hasContentsObserver(Texture *texture) const
{ … }

void Buffer::onContentsChange()
{ … }
}  // namespace gl