#ifndef _GLUDRAWUTIL_HPP
#define _GLUDRAWUTIL_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL Utilities
 * ---------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Draw call utilities.
 *
 * Draw call utilities provide an abstraction for commonly used draw calls.
 * The objective of that abstraction is to allow moving data to buffers
 * and state to VAOs automatically if target context doesn't support
 * user pointers or default VAOs.
 *//*--------------------------------------------------------------------*/

#include "gluDefs.hpp"

#include <string>

namespace glu
{

class RenderContext;

enum VertexComponentType
{
    // Standard types: all conversion types apply.
    VTX_COMP_UNSIGNED_INT8 = 0,
    VTX_COMP_UNSIGNED_INT16,
    VTX_COMP_UNSIGNED_INT32,
    VTX_COMP_SIGNED_INT8,
    VTX_COMP_SIGNED_INT16,
    VTX_COMP_SIGNED_INT32,

    // Special types: only CONVERT_NONE is allowed.
    VTX_COMP_FIXED,
    VTX_COMP_HALF_FLOAT,
    VTX_COMP_FLOAT,

    VTX_COMP_TYPE_LAST
};

enum VertexComponentConversion
{
    VTX_COMP_CONVERT_NONE = 0,           //!< No conversion: integer types, or floating-point values.
    VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT, //!< Normalize integers to range [0,1] or [-1,1] depending on type.
    VTX_COMP_CONVERT_CAST_TO_FLOAT,      //!< Convert to floating-point directly.

    VTX_COMP_CONVERT_LAST
};

enum IndexType
{
    INDEXTYPE_UINT8,
    INDEXTYPE_UINT16,
    INDEXTYPE_UINT32,

    INDEXTYPE_LAST
};

enum PrimitiveType
{
    PRIMITIVETYPE_TRIANGLES = 0,
    PRIMITIVETYPE_TRIANGLE_STRIP,
    PRIMITIVETYPE_TRIANGLE_FAN,

    PRIMITIVETYPE_LINES,
    PRIMITIVETYPE_LINE_STRIP,
    PRIMITIVETYPE_LINE_LOOP,

    PRIMITIVETYPE_POINTS,

    PRIMITIVETYPE_PATCHES,

    PRIMITIVETYPE_LAST
};

struct BindingPoint
{
    enum Type
    {
        BPTYPE_LOCATION = 0, //!< Binding by numeric location.
        BPTYPE_NAME,         //!< Binding by input name.

        BPTYPE_LAST
    };

    Type type;        //!< Binding type (name or location).
    std::string name; //!< Input name, or empty if is not binding by name.
    int location;     //!< Input location, or offset to named location if binding by name.

    BindingPoint(void) : type(BPTYPE_LAST), location(0)
    {
    }
    explicit BindingPoint(int location_) : type(BPTYPE_LOCATION), location(location_)
    {
    }
    explicit BindingPoint(const std::string &name_, int location_ = 0)
        : type(BPTYPE_NAME)
        , name(name_)
        , location(location_)
    {
    }
};

struct VertexArrayPointer
{
    VertexComponentType componentType; //!< Component type.
    VertexComponentConversion convert; //!< Component conversion type.
    int numComponents;                 //!< Number of components per element.
    int numElements;                   //!< Number of elements in total.
    int stride;                        //!< Element stride.

    const void *data; //!< Data pointer.

    VertexArrayPointer(VertexComponentType componentType_, VertexComponentConversion convert_, int numComponents_,
                       int numElements_, int stride_, const void *data_)
        : componentType(componentType_)
        , convert(convert_)
        , numComponents(numComponents_)
        , numElements(numElements_)
        , stride(stride_)
        , data(data_)
    {
    }

    VertexArrayPointer(void)
        : componentType(VTX_COMP_TYPE_LAST)
        , convert(VTX_COMP_CONVERT_LAST)
        , numComponents(0)
        , numElements(0)
        , stride(0)
        , data(0)
    {
    }
} DE_WARN_UNUSED_TYPE;

struct VertexArrayBinding
{
    BindingPoint binding;
    VertexArrayPointer pointer;

    VertexArrayBinding(const BindingPoint &binding_, const VertexArrayPointer &pointer_)
        : binding(binding_)
        , pointer(pointer_)
    {
    }

    VertexArrayBinding(void)
    {
    }
} DE_WARN_UNUSED_TYPE;

struct PrimitiveList
{
    PrimitiveType type;  //!< Primitive type.
    int numElements;     //!< Number of elements to be drawn.
    IndexType indexType; //!< Index type or INDEXTYPE_LAST if not used
    const void *indices; //!< Index list or DE_NULL if not used.

    PrimitiveList(PrimitiveType type_, int numElements_)
        : type(type_)
        , numElements(numElements_)
        , indexType(INDEXTYPE_LAST)
        , indices(0)
    {
    }

    PrimitiveList(PrimitiveType type_, int numElements_, IndexType indexType_, const void *indices_)
        : type(type_)
        , numElements(numElements_)
        , indexType(indexType_)
        , indices(indices_)
    {
    }

    PrimitiveList(void) : type(PRIMITIVETYPE_LAST), numElements(0), indexType(INDEXTYPE_LAST), indices(0)
    {
    }
} DE_WARN_UNUSED_TYPE;

class DrawUtilCallback
{
public:
    virtual void beforeDrawCall(void)
    {
    }
    virtual void afterDrawCall(void)
    {
    }
};

void draw(const RenderContext &context, uint32_t program, int numVertexArrays, const VertexArrayBinding *vertexArrays,
          const PrimitiveList &primitives, DrawUtilCallback *callback = DE_NULL);

void drawFromUserPointers(const RenderContext &context, uint32_t program, int numVertexArrays,
                          const VertexArrayBinding *vertexArrays, const PrimitiveList &primitives,
                          DrawUtilCallback *callback = DE_NULL);
void drawFromBuffers(const RenderContext &context, uint32_t program, int numVertexArrays,
                     const VertexArrayBinding *vertexArrays, const PrimitiveList &primitives,
                     DrawUtilCallback *callback = DE_NULL);
void drawFromVAOBuffers(const RenderContext &context, uint32_t program, int numVertexArrays,
                        const VertexArrayBinding *vertexArrays, const PrimitiveList &primitives,
                        DrawUtilCallback *callback = DE_NULL);

// Shorthands for PrimitiveList
namespace pr
{

#define DECLARE_PR_CTOR(NAME, TYPE)                                         \
    inline PrimitiveList NAME(int numElements)                              \
    {                                                                       \
        return PrimitiveList(TYPE, numElements);                            \
    }                                                                       \
    inline PrimitiveList NAME(int numElements, const uint8_t *indices)      \
    {                                                                       \
        return PrimitiveList(TYPE, numElements, INDEXTYPE_UINT8, indices);  \
    }                                                                       \
    inline PrimitiveList NAME(int numElements, const uint16_t *indices)     \
    {                                                                       \
        return PrimitiveList(TYPE, numElements, INDEXTYPE_UINT16, indices); \
    }                                                                       \
    inline PrimitiveList NAME(int numElements, const uint32_t *indices)     \
    {                                                                       \
        return PrimitiveList(TYPE, numElements, INDEXTYPE_UINT32, indices); \
    }                                                                       \
    struct DeclarePRCtor##NAME##Unused_s                                    \
    {                                                                       \
        int unused;                                                         \
    }

DECLARE_PR_CTOR(Triangles, PRIMITIVETYPE_TRIANGLES);
DECLARE_PR_CTOR(TriangleStrip, PRIMITIVETYPE_TRIANGLE_STRIP);
DECLARE_PR_CTOR(TriangleFan, PRIMITIVETYPE_TRIANGLE_FAN);

DECLARE_PR_CTOR(Lines, PRIMITIVETYPE_LINES);
DECLARE_PR_CTOR(LineStrip, PRIMITIVETYPE_LINE_STRIP);
DECLARE_PR_CTOR(LineLineLoop, PRIMITIVETYPE_LINE_LOOP);

DECLARE_PR_CTOR(Points, PRIMITIVETYPE_POINTS);

DECLARE_PR_CTOR(Patches, PRIMITIVETYPE_PATCHES);

} // namespace pr

// Shorthands for VertexArrayBinding
namespace va
{

#define DECLARE_VA_CTOR(NAME, DATATYPE, TYPE, CONVERT)                                                                 \
    inline VertexArrayBinding NAME(const std::string &name, int offset, int numComponents, int numElements,            \
                                   int stride, const DATATYPE *data)                                                   \
    {                                                                                                                  \
        return VertexArrayBinding(BindingPoint(name, offset),                                                          \
                                  VertexArrayPointer(TYPE, CONVERT, numComponents, numElements, stride, data));        \
    }                                                                                                                  \
    inline VertexArrayBinding NAME(const std::string &name, int numComponents, int numElements, int stride,            \
                                   const DATATYPE *data)                                                               \
    {                                                                                                                  \
        return NAME(name, 0, numComponents, numElements, stride, data);                                                \
    }                                                                                                                  \
    inline VertexArrayBinding NAME(int location, int numComponents, int numElements, int stride, const DATATYPE *data) \
    {                                                                                                                  \
        return VertexArrayBinding(BindingPoint(location),                                                              \
                                  VertexArrayPointer(TYPE, CONVERT, numComponents, numElements, stride, data));        \
    }                                                                                                                  \
    struct DeclareVACtor##NAME##Unused_s                                                                               \
    {                                                                                                                  \
        int unused;                                                                                                    \
    }

// Integer types
DECLARE_VA_CTOR(Uint8, uint8_t, VTX_COMP_UNSIGNED_INT8, VTX_COMP_CONVERT_NONE);
DECLARE_VA_CTOR(Uint16, uint16_t, VTX_COMP_UNSIGNED_INT16, VTX_COMP_CONVERT_NONE);
DECLARE_VA_CTOR(Uint32, uint32_t, VTX_COMP_UNSIGNED_INT32, VTX_COMP_CONVERT_NONE);
DECLARE_VA_CTOR(Int8, int8_t, VTX_COMP_SIGNED_INT8, VTX_COMP_CONVERT_NONE);
DECLARE_VA_CTOR(Int16, int16_t, VTX_COMP_SIGNED_INT16, VTX_COMP_CONVERT_NONE);
DECLARE_VA_CTOR(Int32, int32_t, VTX_COMP_SIGNED_INT32, VTX_COMP_CONVERT_NONE);

// Normalized integers.
DECLARE_VA_CTOR(Unorm8, uint8_t, VTX_COMP_UNSIGNED_INT8, VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
DECLARE_VA_CTOR(Unorm16, uint16_t, VTX_COMP_UNSIGNED_INT16, VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
DECLARE_VA_CTOR(Unorm32, uint32_t, VTX_COMP_UNSIGNED_INT32, VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
DECLARE_VA_CTOR(Snorm8, int8_t, VTX_COMP_SIGNED_INT8, VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
DECLARE_VA_CTOR(Snorm16, int16_t, VTX_COMP_SIGNED_INT16, VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);
DECLARE_VA_CTOR(Snorm32, int32_t, VTX_COMP_SIGNED_INT32, VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT);

// Integers converted to float.
DECLARE_VA_CTOR(Uint8Float, uint8_t, VTX_COMP_UNSIGNED_INT8, VTX_COMP_CONVERT_CAST_TO_FLOAT);
DECLARE_VA_CTOR(Uint16Float, uint16_t, VTX_COMP_UNSIGNED_INT16, VTX_COMP_CONVERT_CAST_TO_FLOAT);
DECLARE_VA_CTOR(Uint32Float, uint32_t, VTX_COMP_UNSIGNED_INT32, VTX_COMP_CONVERT_CAST_TO_FLOAT);
DECLARE_VA_CTOR(Int8Float, int8_t, VTX_COMP_SIGNED_INT8, VTX_COMP_CONVERT_CAST_TO_FLOAT);
DECLARE_VA_CTOR(Int16Float, int16_t, VTX_COMP_SIGNED_INT16, VTX_COMP_CONVERT_CAST_TO_FLOAT);
DECLARE_VA_CTOR(Int32Float, int32_t, VTX_COMP_SIGNED_INT32, VTX_COMP_CONVERT_CAST_TO_FLOAT);

// Special types.
DECLARE_VA_CTOR(Fixed, void, VTX_COMP_FIXED, VTX_COMP_CONVERT_NONE);
DECLARE_VA_CTOR(Half, void, VTX_COMP_HALF_FLOAT, VTX_COMP_CONVERT_NONE);
DECLARE_VA_CTOR(Float, float, VTX_COMP_FLOAT, VTX_COMP_CONVERT_NONE);

#undef DECLARE_VA_CTOR

} // namespace va

} // namespace glu

#endif // _GLUDRAWUTIL_HPP