//
// Copyright 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.
//
// Implementation of the state classes for mananging GLES 3.1 Vertex Array Objects.
//

#include "libANGLE/VertexAttribute.h"
#include "common/mathutil.h"

namespace gl
{

// [OpenGL ES 3.1] (November 3, 2016) Section 20 Page 361
// Table 20.2: Vertex Array Object State
VertexBinding::VertexBinding() : VertexBinding(0) {}

VertexBinding::VertexBinding(GLuint boundAttribute) : mStride(16u), mDivisor(0), mOffset(0)
{
    mBoundAttributesMask.set(boundAttribute);
}

VertexBinding::VertexBinding(VertexBinding &&binding)
{
    *this = std::move(binding);
}

VertexBinding::~VertexBinding() {}

VertexBinding &VertexBinding::operator=(VertexBinding &&binding)
{
    if (this != &binding)
    {
        mStride              = binding.mStride;
        mDivisor             = binding.mDivisor;
        mOffset              = binding.mOffset;
        mBoundAttributesMask = binding.mBoundAttributesMask;
    }
    return *this;
}

VertexAttribute::VertexAttribute(GLuint bindingIndex)
    : enabled(false),
      format(&angle::Format::Get(angle::FormatID::R32G32B32A32_FLOAT)),
      pointer(nullptr),
      relativeOffset(0),
      vertexAttribArrayStride(0),
      bindingIndex(bindingIndex),
      mCachedElementLimit(0)
{}

VertexAttribute::VertexAttribute(VertexAttribute &&attrib)
    : enabled(attrib.enabled),
      format(attrib.format),
      pointer(attrib.pointer),
      relativeOffset(attrib.relativeOffset),
      vertexAttribArrayStride(attrib.vertexAttribArrayStride),
      bindingIndex(attrib.bindingIndex),
      mCachedElementLimit(attrib.mCachedElementLimit)
{}

VertexAttribute &VertexAttribute::operator=(VertexAttribute &&attrib)
{
    if (this != &attrib)
    {
        enabled                 = attrib.enabled;
        format                  = attrib.format;
        pointer                 = attrib.pointer;
        relativeOffset          = attrib.relativeOffset;
        vertexAttribArrayStride = attrib.vertexAttribArrayStride;
        bindingIndex            = attrib.bindingIndex;
        mCachedElementLimit     = attrib.mCachedElementLimit;
    }
    return *this;
}

void VertexAttribute::updateCachedElementLimit(const VertexBinding &binding, GLint64 bufferSize)
{
    if (bufferSize == 0)
    {
        mCachedElementLimit = 0;
        return;
    }

    angle::CheckedNumeric<GLint64> bufferOffset(binding.getOffset());
    angle::CheckedNumeric<GLint64> checkedBufferSize(bufferSize);
    angle::CheckedNumeric<GLint64> attribOffset(relativeOffset);
    angle::CheckedNumeric<GLint64> attribSize(ComputeVertexAttributeTypeSize(*this));

    // Disallow referencing data before the start of the buffer with negative offsets
    angle::CheckedNumeric<GLint64> offset = bufferOffset + attribOffset;
    if (!offset.IsValid() || offset.ValueOrDie() < 0)
    {
        mCachedElementLimit = kIntegerOverflow;
        return;
    }

    // The element limit is (exclusive) end of the accessible range for the vertex.  For example, if
    // N attributes can be accessed, the following calculates N.
    //
    // (buffer.size - buffer.offset - attrib.relativeOffset - attrib.size) / binding.stride + 1
    angle::CheckedNumeric<GLint64> elementLimit = (checkedBufferSize - offset - attribSize);

    // Use the special integer overflow value if there was a math error.
    if (!elementLimit.IsValid())
    {
        static_assert(kIntegerOverflow < 0, "Unexpected value");
        mCachedElementLimit = kIntegerOverflow;
        return;
    }

    mCachedElementLimit = elementLimit.ValueOrDie();
    if (mCachedElementLimit < 0)
    {
        return;
    }

    if (binding.getStride() == 0)
    {
        // Special case for a zero stride. If we can fit one vertex we can fit infinite vertices.
        mCachedElementLimit = std::numeric_limits<GLint64>::max();
        return;
    }

    mCachedElementLimit /= binding.getStride();
    ++mCachedElementLimit;
}

size_t ComputeVertexAttributeStride(const VertexAttribute &attrib, const VertexBinding &binding)
{
    // In ES 3.1, VertexAttribPointer will store the type size in the binding stride.
    // Hence, rendering always uses the binding's stride.
    return attrib.enabled ? binding.getStride() : 16u;
}

// Warning: you should ensure binding really matches attrib.bindingIndex before using this function.
uintptr_t ComputeVertexAttributeOffset(const VertexAttribute &attrib, const VertexBinding &binding)
{
    return attrib.relativeOffset + binding.getOffset();
}

size_t ComputeVertexBindingElementCount(GLuint divisor,
                                        uint64_t drawCount,
                                        size_t instanceCount,
                                        uint64_t baseInstance)
{
    // For instanced rendering, we draw "instanceDrawCount" sets of "vertexDrawCount" vertices.
    //
    // A vertex attribute with a positive divisor loads one instanced vertex for every set of
    // non-instanced vertices, and the instanced vertex index advances once every "mDivisor"
    // instances.
    if (instanceCount > 0 && divisor > 0)
    {
        // When instanceDrawCount is not a multiple of divisor, the division must round up.
        // For instance, with 5 non-instanced vertices and a divisor equal to 3, we need 2 instanced
        // vertices.
        angle::CheckedNumeric<size_t> checkedElementCount = baseInstance;
        checkedElementCount += static_cast<size_t>(rx::UnsignedCeilDivide64(
            static_cast<uint64_t>(instanceCount), static_cast<uint64_t>(divisor)));
        return checkedElementCount.ValueOrDie();
    }

    // Ensure that drawCount can always fit into a size_t. This should also be validated by
    // maxElementIndex.
    return angle::CheckedNumeric<size_t>(drawCount).ValueOrDie();
}

std::ostream &operator<<(std::ostream &os, const VertexAttribCurrentValueData &data)
{
    auto printTypedData = [](std::ostream &os, auto data) {
        os << "x = " << data[0] << ", y = " << data[1] << ", z = " << data[2]
           << ", w = " << data[3];
    };

    switch (data.Type)
    {
        case gl::VertexAttribType::Float:
            os << "Type = Float, ";
            printTypedData(os, data.Values.FloatValues);
            break;
        case gl::VertexAttribType::Int:
            os << "Type = Int, ";
            printTypedData(os, data.Values.IntValues);
            break;

        case gl::VertexAttribType::UnsignedInt:
            os << "Type = UnsignedInt, ";
            printTypedData(os, data.Values.UnsignedIntValues);
            break;
        default:
            UNREACHABLE();
    }
    return os;
}

}  // namespace gl