//
// Copyright 2015 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.
//

// BufferGL.cpp: Implements the class methods for BufferGL.

#include "libANGLE/renderer/gl/BufferGL.h"
#include "common/unsafe_buffers.h"

#include "common/debug.h"
#include "common/utilities.h"
#include "libANGLE/Context.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/gl/ContextGL.h"
#include "libANGLE/renderer/gl/FunctionsGL.h"
#include "libANGLE/renderer/gl/StateManagerGL.h"
#include "libANGLE/renderer/gl/renderergl_utils.h"

namespace rx
{

namespace
{

bool KeepBufferShadowCopy(const gl::Context *context, gl::WebGLBufferType webglType)
{
    // Always keep a shadow copy if the feature is enabled. This usually means there is no other way
    // to read back the data.
    const angle::FeaturesGL &features = GetFeaturesGL(context);
    if (features.keepBufferShadowCopy.enabled)
    {
        return true;
    }

    // Shadow WebGL index buffers when the driver is unable to provide robust access.
    // WebGL element array buffers cannot be bound to other binding points or written to on the GPU
    // so the shadowed data will never be invalidated.
    if (context->isWebGL() && context->isBufferAccessValidationEnabled() &&
        webglType == gl::WebGLBufferType::ElementArray)
    {
        return true;
    }

    return false;
}

}  // namespace

// Use the GL_COPY_READ_BUFFER binding when two buffers need to be bound simultaneously.
// GL_ELEMENT_ARRAY_BUFFER is supported on more versions but can modify the state of the currently
// bound VAO.  Two simultaneous buffer bindings are only needed for glCopyBufferSubData which also
// adds the GL_COPY_READ_BUFFER binding.
static constexpr gl::BufferBinding SourceBufferOperationTarget = gl::BufferBinding::CopyRead;

// Use the GL_ELEMENT_ARRAY_BUFFER binding for most operations since it's available on all
// supported GL versions and doesn't affect any current state when it changes.
static constexpr gl::BufferBinding DestBufferOperationTarget = gl::BufferBinding::Array;

BufferGL::BufferGL(const gl::BufferState &state, GLuint buffer)
    : BufferImpl(state),
      mIsMapped(false),
      mMapOffset(0),
      mMapSize(0),
      mShadowCopy(),
      mBufferSize(0),
      mBufferID(buffer)
{}

BufferGL::~BufferGL()
{
    ASSERT(mBufferID == 0);
}

void BufferGL::destroy(const gl::Context *context)
{
    StateManagerGL *stateManager = GetStateManagerGL(context);
    stateManager->deleteBuffer(mBufferID);
    mBufferID = 0;
}

angle::Result BufferGL::setData(const gl::Context *context,
                                gl::BufferBinding target,
                                const void *data,
                                size_t size,
                                gl::BufferUsage usage,
                                BufferFeedback *feedback,
                                gl::ZeroFillRequired zeroFillRequired)
{
    ContextGL *contextGL         = GetImplAs<ContextGL>(context);
    const FunctionsGL *functions = GetFunctionsGL(context);
    StateManagerGL *stateManager = GetStateManagerGL(context);

    // Initialize the shadow buffer if needed. Don't delete existing shadow data. WebGL allows users
    // to bind as an element array buffer first and then copy source/dest later (but not the other
    // way around).
    if (KeepBufferShadowCopy(context, mState.getWebGLType()) && !mShadowCopy.has_value())
    {
        mShadowCopy = angle::MemoryBuffer();
    }

    stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);

    const void *uploadData = data;
    if (zeroFillRequired == gl::ZeroFillRequired::Yes)
    {
        const angle::MemoryBuffer *scratchBuffer = nullptr;
        ANGLE_CHECK_GL_ALLOC(
            contextGL, context->getZeroFilledBuffer(static_cast<size_t>(size), &scratchBuffer));
        uploadData = scratchBuffer->data();
    }

    if (mShadowCopy.has_value())
    {
        ANGLE_CHECK_GL_ALLOC(contextGL, mShadowCopy->resize(size));

        if (size > 0 && uploadData != nullptr)
        {
            ANGLE_UNSAFE_TODO(memcpy(mShadowCopy->data(), uploadData, size));
            uploadData = mShadowCopy->data();
        }
    }

    ANGLE_GL_TRY_ALWAYS_CHECK(
        context, functions->bufferData(gl::ToGLenum(DestBufferOperationTarget), size, uploadData,
                                       ToGLenum(usage)));

    mBufferSize = size;

    contextGL->markWorkSubmitted();

    return angle::Result::Continue;
}

angle::Result BufferGL::setSubData(const gl::Context *context,
                                   gl::BufferBinding target,
                                   const void *data,
                                   size_t size,
                                   size_t offset,
                                   BufferFeedback *feedback)
{
    ContextGL *contextGL         = GetImplAs<ContextGL>(context);
    const FunctionsGL *functions = GetFunctionsGL(context);
    StateManagerGL *stateManager = GetStateManagerGL(context);

    stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);

    const void *uploadData = data;

    if (mShadowCopy.has_value())
    {
        if (size > 0 && data != nullptr)
        {
            ANGLE_UNSAFE_TODO(memcpy(mShadowCopy->data() + offset, data, size));
            uploadData = ANGLE_UNSAFE_TODO(mShadowCopy->data() + offset);
        }
    }

    ANGLE_GL_TRY(context, functions->bufferSubData(gl::ToGLenum(DestBufferOperationTarget), offset,
                                                   size, uploadData));

    contextGL->markWorkSubmitted();

    return angle::Result::Continue;
}

angle::Result BufferGL::copySubData(const gl::Context *context,
                                    BufferImpl *source,
                                    GLintptr sourceOffset,
                                    GLintptr destOffset,
                                    GLsizeiptr size,
                                    BufferFeedback *feedback)
{
    ContextGL *contextGL         = GetImplAs<ContextGL>(context);
    const FunctionsGL *functions = GetFunctionsGL(context);
    StateManagerGL *stateManager = GetStateManagerGL(context);

    BufferGL *sourceGL = GetAs<BufferGL>(source);

    stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
    stateManager->bindBuffer(SourceBufferOperationTarget, sourceGL->getBufferID());

    ANGLE_GL_TRY(context, functions->copyBufferSubData(gl::ToGLenum(SourceBufferOperationTarget),
                                                       gl::ToGLenum(DestBufferOperationTarget),
                                                       sourceOffset, destOffset, size));

    if (mShadowCopy.has_value() && size > 0)
    {
        // WebGL only allows copying between buffers that are marked as the same type. Both buffers
        // would have to be element array buffers and have shadow data.
        ASSERT(sourceGL->mShadowCopy.has_value());

        ASSERT(sourceGL->mShadowCopy->size() >= static_cast<size_t>(sourceOffset + size));
        ANGLE_UNSAFE_TODO(memcpy(mShadowCopy->data() + destOffset,
                                 sourceGL->mShadowCopy->data() + sourceOffset, size));
    }

    contextGL->markWorkSubmitted();

    return angle::Result::Continue;
}

angle::Result BufferGL::map(const gl::Context *context,
                            GLenum access,
                            void **mapPtr,
                            BufferFeedback *feedback)
{
    ContextGL *contextGL         = GetImplAs<ContextGL>(context);
    const FunctionsGL *functions = GetFunctionsGL(context);
    StateManagerGL *stateManager = GetStateManagerGL(context);

    if (mShadowCopy.has_value())
    {
        *mapPtr = mShadowCopy->data();
    }
    else
    {
        stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
        if (functions->mapBuffer)
        {
            *mapPtr = ANGLE_GL_TRY(
                context, functions->mapBuffer(gl::ToGLenum(DestBufferOperationTarget), access));
        }
        else
        {
            ASSERT(functions->mapBufferRange && access == GL_WRITE_ONLY_OES);
            *mapPtr = ANGLE_GL_TRY(
                context, functions->mapBufferRange(gl::ToGLenum(DestBufferOperationTarget), 0,
                                                   mBufferSize, GL_MAP_WRITE_BIT));
        }

        // Unbind the mapped buffer from the array buffer binding. Some drivers generate errors if
        // any mapped buffer is bound to array buffer bindings.
        // crbug.com/1345777
        stateManager->bindBuffer(DestBufferOperationTarget, 0);
    }

    mIsMapped  = true;
    mMapOffset = 0;
    mMapSize   = mBufferSize;

    contextGL->markWorkSubmitted();

    return angle::Result::Continue;
}

angle::Result BufferGL::mapRange(const gl::Context *context,
                                 size_t offset,
                                 size_t length,
                                 GLbitfield access,
                                 void **mapPtr,
                                 BufferFeedback *feedback)
{
    ContextGL *contextGL         = GetImplAs<ContextGL>(context);
    const FunctionsGL *functions = GetFunctionsGL(context);
    StateManagerGL *stateManager = GetStateManagerGL(context);

    if (mShadowCopy.has_value())
    {
        *mapPtr = ANGLE_UNSAFE_TODO(mShadowCopy->data() + offset);
    }
    else
    {
        stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
        *mapPtr =
            ANGLE_GL_TRY(context, functions->mapBufferRange(gl::ToGLenum(DestBufferOperationTarget),
                                                            offset, length, access));

        // Unbind the mapped buffer from the array buffer binding. Some drivers generate errors if
        // any mapped buffer is bound to array buffer bindings.
        // crbug.com/1345777
        stateManager->bindBuffer(DestBufferOperationTarget, 0);
    }

    mIsMapped  = true;
    mMapOffset = offset;
    mMapSize   = length;

    contextGL->markWorkSubmitted();

    return angle::Result::Continue;
}

angle::Result BufferGL::unmap(const gl::Context *context,
                              GLboolean *result,
                              BufferFeedback *feedback)
{
    ContextGL *contextGL         = GetImplAs<ContextGL>(context);
    const FunctionsGL *functions = GetFunctionsGL(context);
    StateManagerGL *stateManager = GetStateManagerGL(context);

    ASSERT(result);
    ASSERT(mIsMapped);

    if (mShadowCopy.has_value())
    {
        stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
        ANGLE_UNSAFE_TODO(ANGLE_GL_TRY(
            context, functions->bufferSubData(gl::ToGLenum(DestBufferOperationTarget), mMapOffset,
                                              mMapSize, mShadowCopy->data() + mMapOffset)));
        *result = GL_TRUE;
    }
    else
    {
        stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
        *result =
            ANGLE_GL_TRY(context, functions->unmapBuffer(gl::ToGLenum(DestBufferOperationTarget)));
    }

    mIsMapped = false;

    contextGL->markWorkSubmitted();

    return angle::Result::Continue;
}

angle::Result BufferGL::getIndexRange(const gl::Context *context,
                                      gl::DrawElementsType type,
                                      size_t offset,
                                      size_t count,
                                      bool primitiveRestartEnabled,
                                      gl::IndexRange *outRange)
{
    ContextGL *contextGL         = GetImplAs<ContextGL>(context);
    const FunctionsGL *functions = GetFunctionsGL(context);
    StateManagerGL *stateManager = GetStateManagerGL(context);

    ASSERT(!mIsMapped);

    if (mShadowCopy.has_value())
    {
        *outRange = gl::ComputeIndexRange(type, ANGLE_UNSAFE_TODO(mShadowCopy->data() + offset),
                                          count, primitiveRestartEnabled);
    }
    else
    {
        stateManager->bindBuffer(DestBufferOperationTarget, mBufferID);

        const GLuint typeBytes = gl::GetDrawElementsTypeSize(type);
        const uint8_t *bufferData =
            MapBufferRangeWithFallback(functions, gl::ToGLenum(DestBufferOperationTarget), offset,
                                       count * typeBytes, GL_MAP_READ_BIT);
        if (bufferData)
        {
            *outRange = gl::ComputeIndexRange(type, bufferData, count, primitiveRestartEnabled);
            ANGLE_GL_TRY(context, functions->unmapBuffer(gl::ToGLenum(DestBufferOperationTarget)));
        }
        else
        {
            // Workaround the null driver not having map support.
            *outRange = gl::IndexRange(0, 0);
        }
    }

    contextGL->markWorkSubmitted();

    return angle::Result::Continue;
}

size_t BufferGL::getBufferSize() const
{
    return mBufferSize;
}

GLuint BufferGL::getBufferID() const
{
    return mBufferID;
}
}  // namespace rx
