/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef MultiDrawElements_INCLUDE_ONCE
#define MultiDrawElements_INCLUDE_ONCE

#include <vlGraphics/DrawCall.hpp>
#include <vlGraphics/Array.hpp>
#include <vlGraphics/TriangleIterator.hpp>
#include <vlCore/Log.hpp>
#include <vlCore/Say.hpp>
#include <algorithm>

namespace vl
{
  //------------------------------------------------------------------------------
  // MultiDrawElementsBase
  //------------------------------------------------------------------------------
  /**
   * Base interface for all MultiDrawElements* sub classes.
   * Implements the index-type-independent interface of the class. That is you can cast to MultiDrawElementsBase*
   * and access its members without needing to know whether the actual class is a
   * vl::MultiDrawElementsUInt, vl::MultiDrawElementsUShort or vl::MultiDrawElementsUByte. */
  class MultiDrawElementsBase: public DrawCall
  {
    VL_INSTRUMENT_ABSTRACT_CLASS(vl::MultiDrawElementsBase, DrawCall)

  public:
    /** Returns whether the primitive-restart functionality is enabled or not. See http://www.opengl.org/registry/specs/NV/primitive_restart.txt */
    virtual bool primitiveRestartEnabled() const { return mPrimitiveRestartEnabled; }

    /** Enables the primitive-restart functionality. See http://www.opengl.org/registry/specs/NV/primitive_restart.txt */
    void setPrimitiveRestartEnabled(bool enabled) { mPrimitiveRestartEnabled = enabled; }

    /** Calls computePointerVector(), computeBufferObjectPointerVector() and resizes the base vertex array to fit the count vector.
      * @note Must be called after the index buffer has been filled. */
    void finalizeSetup()
    {
      // update pointers
      computePointerVector();
      computeBufferObjectPointerVector();
      // set default base vertices to 0
      if (mBaseVertices.size() != mCountVector.size())
        mBaseVertices.resize(mCountVector.size());
    }

    /** Sets the vector defining the length of each primitive and automatically computes the pointer vectors used to exectue glMultiDrawElements().
      * @note Must be called after the index buffer has been filled. */
    void setCountVector(const std::vector<GLsizei>& vcount)
    {
      mCountVector = vcount;
      finalizeSetup();
    }

    /** Sets the vector defining the length of each primitive and automatically computes the pointer vectors used to exectue glMultiDrawElements().
      * @note Must be called after the index buffer has been filled. */
    void setCountVector(const GLsizei* vcount, size_t size)
    {
      mCountVector.resize(size);
      for(size_t i=0; i<size; ++i)
        mCountVector[i] = vcount[i];
      finalizeSetup();
    }

    /** The count vector used as 'count' parameter of glMultiDrawElements. */
    const std::vector<GLsizei>& countVector() const { return mCountVector; }

    /** The count vector used as 'count' parameter of glMultiDrawElements. */
    std::vector<GLsizei>& countVector() { return mCountVector; }

    /** Returns the list of base vertices, one for each primitive. This will enable the use
      * of glMultiDrawElementsBaseVertex() to render a set of primitives.
      * See also http://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawElementsBaseVertex.xml */
    void setBaseVertices(const std::vector<GLint>& base_verts) { mBaseVertices = base_verts; }

    /** Returns the list of base vertices, one for each primitive. */
    const std::vector<GLint>& baseVertices() const { return mBaseVertices; }

    /** Returns the list of base vertices, one for each primitive. */
    std::vector<GLint>& baseVertices() { return mBaseVertices; }

    /** Computes the pointer vector to be used when BufferObjects are DISABLED. Call this function after having updated the count vector and the index buffer indexBuffer().
     * @note Normally you don't need to call this function as setCountVector() already calls it. */
    virtual void computePointerVector() = 0;

    /** Computes the pointer vector to be used when BufferObjects are ENABLED. Call this function after having updated the count vector and the index buffer indexBuffer().
     * @note Normally you don't need to call this function as setCountVector() already calls it. */
    virtual void computeBufferObjectPointerVector() = 0;

  protected:
    bool mPrimitiveRestartEnabled;
    std::vector<GLsizei> mCountVector;
    std::vector<GLint>   mBaseVertices;
  };
  //------------------------------------------------------------------------------
  // MultiDrawElements
  //------------------------------------------------------------------------------
  /**
   * Wrapper for the OpenGL function glMultiDrawElements(). See vl::DrawCall for an overview of the different draw call methods.
   *
   * This class wraps the following OpenGL functions:
   * - glMultiDrawElements (http://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawElements.xml)
   * - glMultiDrawElementsBaseVertex (http://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawElementsBaseVertex.xml)
   *
   * Supports:
   * - <b>Multi instancing</b>: NO
   * - <b>Base vertex</b>: YES
   * - <b>Primitive restart</b>: YES
   *
   * Use the functions setPrimitiveRestartIndex() and setPrimitiveRestartEnabled() to use the <b>primitive
   * restart</b> functionality (requires OpenGL 3.1). For more information see http://www.opengl.org/sdk/docs/man3/xhtml/glPrimitiveRestartIndex.xml
   *
   * Use the function setBaseVertices() to use the <b>base vertex</b> functionality.
   * Requires OpenGL 3.2 or GL_ARB_draw_elements_base_vertex. For more information see http://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawElementsBaseVertex.xml
   *
   * DrawElements, MultiDrawElements, DrawRangeElements, DrawArrays are used by Geometry to define a set of primitives to be rendered, see Geometry::drawCalls().
   * The indices are stored in a BufferObject and thus they can be stored locally or on the GPU.
   * To gain direct access to the BufferObject use the indexBuffer() function.
   *
   * DrawArrays, DrawElements, MultiDrawElements and DrawRangeElements are used by Geometry to define a set of primitives to be rendered.
   * @sa Geometry::drawCalls(), DrawCall, DrawElements, MultiDrawElements, DrawRangeElements, Geometry, Actor */
  template <class arr_type>
  class MultiDrawElements: public MultiDrawElementsBase
  {
    VL_INSTRUMENT_CLASS(vl::MultiDrawElements<arr_type>, MultiDrawElementsBase)

  public:
    typedef typename arr_type::scalar_type index_type;
    //! The special index which identifies a primitive restart. By default it is set to ~0 that is 0xFF, 0xFFFF, 0xFFFFFFFF respectively for GLubyte, GLushort, GLuint index types. */
    static const index_type primitive_restart_index = index_type(~0);
    virtual unsigned int primitiveRestartIndex() { return (unsigned int)primitive_restart_index; }

  public:
    MultiDrawElements(EPrimitiveType primitive = PT_TRIANGLES)
    {
      VL_DEBUG_SET_OBJECT_NAME()
      mType                    = primitive;
      mIndexBuffer             = new arr_type;
      mPrimitiveRestartEnabled = false;
    }

    MultiDrawElements& operator=(const MultiDrawElements& other)
    {
      super::operator=(other);
      *indexBuffer() = *other.indexBuffer();
      mPrimitiveRestartEnabled = other.mPrimitiveRestartEnabled;
      setCountVector(other.mCountVector);
      return *this;
    }

    virtual ref<DrawCall> clone() const
    {
      ref<MultiDrawElements> de = new MultiDrawElements;
      *de = *this;
      return de;
    }

    void setIndexBuffer(arr_type* index_buffer) { mIndexBuffer = index_buffer; }

    arr_type* indexBuffer() { return mIndexBuffer.get(); }

    const arr_type* indexBuffer() const { return mIndexBuffer.get(); }

    virtual void updateDirtyBufferObject(EBufferObjectUpdateMode mode)
    {
      if (indexBuffer()->isBufferObjectDirty() || (mode & BUF_ForceUpdate))
        indexBuffer()->updateBufferObject(mode);
    }

    virtual void deleteBufferObject()
    {
      indexBuffer()->bufferObject()->deleteBufferObject();
    }

    virtual void render(bool use_bo) const
    {
      VL_CHECK_OGL()
      VL_CHECK(Has_GL_EXT_multi_draw_arrays||Has_GL_Version_1_4||Has_GL_Version_3_0||Has_GL_Version_4_0);
      VL_CHECK(!use_bo || (use_bo && Has_BufferObject))
      use_bo &= Has_BufferObject; // && indexBuffer()->bufferObject()->handle() && indexBuffer()->sizeBufferObject();
      if ( !use_bo && !indexBuffer()->size() )
        return;

      // apply patch parameters if any and if using PT_PATCHES
      applyPatchParameters();

      // primitive restart enable
      if(primitiveRestartEnabled())
      {
        VL_CHECK(Has_Primitive_Restart);
        glEnable(GL_PRIMITIVE_RESTART); VL_CHECK_OGL();
        glPrimitiveRestartIndex(primitive_restart_index); VL_CHECK_OGL();
      }

      const GLvoid **indices_ptr = NULL;
      if (use_bo && indexBuffer()->bufferObject()->handle())
      {
        VL_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer()->bufferObject()->handle()); VL_CHECK_OGL()
        VL_CHECK(!mBufferObjectPointerVector.empty())
        indices_ptr = (const GLvoid**)&mBufferObjectPointerVector[0];
      }
      else
      {
        VL_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        VL_CHECK(!mPointerVector.empty())
        indices_ptr = (const GLvoid**)&mPointerVector[0];
      }

      if (baseVertices().size())
      {
        VL_CHECK( baseVertices().size() == pointerVector().size() )
        VL_CHECK( baseVertices().size() == countVector().size() )
        if (Has_GL_ARB_draw_elements_base_vertex||Has_GL_Version_3_1||Has_GL_Version_4_0)
        {
          glMultiDrawElementsBaseVertex( primitiveType(), (GLsizei*)&mCountVector[0], indexBuffer()->glType(), indices_ptr, (GLsizei)mCountVector.size(), (GLint*)&mBaseVertices[0] ); VL_CHECK_OGL()
        }
        else
        {
          vl::Log::error("MultiDrawElements::render(): glMultiDrawElementsBaseVertex() not supported!\n"
            "OpenGL 3.1 or GL_ARB_draw_elements_base_vertex extension required.\n"
          );
        }
      }
      else
      {
        glMultiDrawElements( primitiveType(), (GLsizei*)&mCountVector[0], indexBuffer()->glType(), (const GLvoid**)indices_ptr, (GLsizei)mCountVector.size() ); VL_CHECK_OGL()
      }

      // primitive restart disable
      if(primitiveRestartEnabled())
      {
        glDisable(GL_PRIMITIVE_RESTART); VL_CHECK_OGL()
      }
    }

    TriangleIterator triangleIterator() const;

    IndexIterator indexIterator() const
    {
      ref< IndexIteratorElements<arr_type> > iie = new IndexIteratorElements<arr_type>;
      iie->initialize( mIndexBuffer.get(), &mBaseVertices, &mCountVector, 0, mPrimitiveRestartEnabled, primitive_restart_index );
      IndexIterator iit;
      iit.initialize( iie.get() );
      return iit;
    }

    /** The pointer vector used as 'indices' parameter of glMultiDrawElements when NOT using BufferObjects.
     * Automatically computed when calling setCountVector(). If you need to modify this manually then you also have to modify the bufferObjectPointerVector. */
    const std::vector<const index_type*>& pointerVector() const { return mPointerVector; }

    /** The pointer vector used as 'indices' parameter of glMultiDrawElements when NOT using BufferObjects. */
    std::vector<const index_type*>& pointerVector() { return mPointerVector; }

    /** The pointer vector used as 'indices' parameter of glMultiDrawElements when using BufferObjects. */
    const std::vector<const index_type*>& bufferObjectPointerVector() const { return mBufferObjectPointerVector; }

    /** The pointer vector used as 'indices' parameter of glMultiDrawElements when using BufferObjects. */
    std::vector<const index_type*>& bufferObjectPointerVector() { return mBufferObjectPointerVector; }

    /** Computes pointerVector() based on the values contained on countVector(). */
    void computePointerVector()
    {
      VL_CHECK( indexBuffer() && indexBuffer()->size() )
      mPointerVector.resize( mCountVector.size() );
      const index_type* ptr = (const index_type*)indexBuffer()->bufferObject()->ptr();
      for(size_t i=0; i<mCountVector.size(); ++i)
      {
        mPointerVector[i] = ptr;
        ptr += mCountVector[i];
      }
    }

    //! Computes bufferObjectPointerVector() based on the values contained in pointerVector().
    void computeBufferObjectPointerVector()
    {
      VL_CHECK( indexBuffer() && indexBuffer()->size() )
      mBufferObjectPointerVector.resize( mPointerVector.size() );
      const index_type* base_ptr = (const index_type*)indexBuffer()->ptr();
      VL_CHECK(base_ptr)
      for(size_t i=0; i<mPointerVector.size(); ++i)
      {
        size_t offset = mPointerVector[i] - base_ptr;
        mBufferObjectPointerVector[i] = (const index_type*)0 + offset;
      }
    }

  protected:
    ref< arr_type > mIndexBuffer;
    std::vector<const index_type*> mPointerVector;
    std::vector<const index_type*> mBufferObjectPointerVector;
  };
  //------------------------------------------------------------------------------
  // typedefs
  //------------------------------------------------------------------------------
  /** See MultiDrawElements. A MultiDrawElements using indices of type \p GLuint. */
  class MultiDrawElementsUInt: public MultiDrawElements<ArrayUInt1>
  {
    VL_INSTRUMENT_CLASS(vl::MultiDrawElementsUInt, MultiDrawElements< ArrayUInt1>)

  public:
    MultiDrawElementsUInt(EPrimitiveType primitive = PT_TRIANGLES)
    :MultiDrawElements<ArrayUInt1>(primitive)
    {
      VL_DEBUG_SET_OBJECT_NAME();
    }
  };
  //------------------------------------------------------------------------------
  /** See MultiDrawElements. A MultiDrawElements using indices of type \p GLushort. */
  class MultiDrawElementsUShort: public MultiDrawElements<ArrayUShort1>
  {
    VL_INSTRUMENT_CLASS(vl::MultiDrawElementsUShort, MultiDrawElements< ArrayUShort1>)

  public:
    MultiDrawElementsUShort(EPrimitiveType primitive = PT_TRIANGLES)
    :MultiDrawElements<ArrayUShort1>(primitive)
    {
      VL_DEBUG_SET_OBJECT_NAME();
    }
  };
  //------------------------------------------------------------------------------
  /** See MultiDrawElements. A MultiDrawElements using indices of type \p GLubyte. */
  class MultiDrawElementsUByte: public MultiDrawElements<ArrayUByte1>
  {
    VL_INSTRUMENT_CLASS(vl::MultiDrawElementsUByte, MultiDrawElements<ArrayUByte1>)

  public:
    MultiDrawElementsUByte(EPrimitiveType primitive = PT_TRIANGLES)
    :MultiDrawElements<ArrayUByte1>(primitive)
    {
      VL_DEBUG_SET_OBJECT_NAME();
    }
  };
//-----------------------------------------------------------------------------
  template <class arr_type>
  TriangleIterator MultiDrawElements<arr_type>::triangleIterator() const
  {
    ref< TriangleIteratorMulti<arr_type> > it =
      new TriangleIteratorMulti<arr_type>( &mBaseVertices, &mCountVector, mIndexBuffer.get(), primitiveType(),
          primitiveRestartEnabled(), primitive_restart_index );
    it->initialize();
    return TriangleIterator(it.get());
  }
//-----------------------------------------------------------------------------
}

#endif