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

// ImageIndex.h: A helper struct for indexing into an Image array

#ifndef LIBANGLE_IMAGE_INDEX_H_
#define LIBANGLE_IMAGE_INDEX_H_

#include "common/PackedEnums.h"
#include "common/mathutil.h"
#include "libANGLE/angletypes.h"

#include "angle_gl.h"

namespace egl
{
struct ImageSourceAttributes;
}

namespace gl
{

class ImageIndexIterator;

class ImageIndex
{
  public:
    ImageIndex();
    ImageIndex(const ImageIndex &other);
    ImageIndex &operator=(const ImageIndex &other);

    TextureType getType() const { return mType; }
    GLint getLevelIndex() const { return mLevelIndex; }
    GLint getLayerIndex() const { return mLayerIndex; }
    GLint getLayerCount() const { return mLayerCount; }

    bool hasLayer() const;
    bool has3DLayer() const;
    bool usesTex3D() const;
    GLint cubeMapFaceIndex() const;
    bool valid() const;
    // Note that you cannot use this function when the ImageIndex represents an entire level of cube
    // map.
    TextureTarget getTarget() const;
    TextureTarget getTargetOrFirstCubeFace() const;

    bool isLayered() const;
    bool isEntireLevelCubeMap() const;

    static ImageIndex MakeBuffer();
    static ImageIndex Make2D(GLint levelIndex);
    static ImageIndex MakeRectangle(GLint levelIndex);
    static ImageIndex MakeCubeMapFace(TextureTarget target, GLint levelIndex);
    static ImageIndex Make2DArray(GLint levelIndex, GLint layerIndex = kEntireLevel);
    static ImageIndex Make2DArrayRange(GLint levelIndex, GLint layerIndex, GLint layerCount);
    static ImageIndex Make3D(GLint levelIndex, GLint layerIndex = kEntireLevel);
    static ImageIndex MakeFromTarget(TextureTarget target, GLint levelIndex, GLint depth = 0);
    static ImageIndex MakeFromType(TextureType type,
                                   GLint levelIndex,
                                   GLint layerIndex = kEntireLevel,
                                   GLint layerCount = 1);
    static ImageIndex Make2DMultisample();
    static ImageIndex Make2DMultisampleArray(GLint layerIndex = kEntireLevel);
    static ImageIndex Make2DMultisampleArrayRange(GLint layerIndex, GLint layerCount);

    static constexpr GLint kEntireLevel = static_cast<GLint>(-1);

    bool operator<(const ImageIndex &b) const;
    bool operator==(const ImageIndex &b) const;
    bool operator!=(const ImageIndex &b) const;

    // Only valid for 3D/Cube textures with layers.
    ImageIndexIterator getLayerIterator(GLint layerCount) const;

  private:
    friend class ImageIndexIterator;

    ImageIndex(TextureType type, GLint leveIndex, GLint layerIndex, GLint layerCount);

    TextureType mType;
    GLint mLevelIndex;
    GLint mLayerIndex;
    GLint mLayerCount;
};

// To be used like this:
//
// ImageIndexIterator it = ...;
// while (it.hasNext())
// {
//     ImageIndex current = it.next();
// }
class ImageIndexIterator
{
  public:
    ImageIndexIterator(const ImageIndexIterator &other);

    static ImageIndexIterator MakeBuffer();
    static ImageIndexIterator Make2D(GLint minMip, GLint maxMip);
    static ImageIndexIterator MakeRectangle(GLint minMip, GLint maxMip);
    static ImageIndexIterator MakeCube(GLint minMip, GLint maxMip);
    static ImageIndexIterator Make3D(GLint minMip, GLint maxMip, GLint minLayer, GLint maxLayer);
    static ImageIndexIterator Make2DArray(GLint minMip, GLint maxMip, const GLsizei *layerCounts);
    static ImageIndexIterator Make2DMultisample();
    static ImageIndexIterator Make2DMultisampleArray(const GLsizei *layerCounts);
    static ImageIndexIterator MakeGeneric(TextureType type,
                                          GLint minMip,
                                          GLint maxMip,
                                          GLint minLayer,
                                          GLint maxLayer);

    ImageIndex next();
    ImageIndex current() const;
    bool hasNext() const;

  private:
    ImageIndexIterator(TextureType type,
                       const Range<GLint> &mipRange,
                       const Range<GLint> &layerRange,
                       const GLsizei *layerCounts);

    GLint maxLayer() const;

    const Range<GLint> mMipRange;
    const Range<GLint> mLayerRange;
    const GLsizei *const mLayerCounts;

    ImageIndex mCurrentIndex;
};

TextureTarget TextureTypeToTarget(TextureType type, GLint layerIndex);

// A |Texture| can have a number of levels and layers.  An EGL image may be created out of the
// texture, viewing a specific level and layer specified by EGL_GL_TEXTURE_LEVEL_KHR and
// EGL_GL_TEXTURE_ZOFFSET_KHR.  The EGL image can then be imported into another texture whose own
// state does not include these offsets (e.g. the texture is accessed at level 0).  It may similarly
// be imported into a renderbuffer that doesn't even have a level and layer state.  It's easy to
// confuse which gl::ImageIndex translates to the (backend's) backing image's level/layer.
//
// For example, consider the source texture as defined as having 4 levels, with base level 2.  The
// EGL image is created with EGL_GL_TEXTURE_LEVEL_KHR = 3, and imported into the target texture
// Then:
//
// * The backing image (such as VkImage) can be created with 2 levels, corresponding to the source
//   texture's levels 2 and 3.
// * The target texture's base level (always 0) maps to the backing image's level 1, which is 3 (the
//   EGL image level) minus 2 (base level).
//
// To avoid all confusions, two sets of types exist:
//
// * LevelIndex, LayerIndex, and ImageIndex: these contain levels and layers from the point of view
//   of the current texture, be it the source or target texture.  They correspond to the front-end's
//   state, and are passed to the backend.
// * OwnerLevel, OwnerLayer, and OwnerImageIndex: these contain levels and layers corresponding to
//   the source texture (owner of the backing storage).  For the source texture itself, these are
//   equal to the other variants.  For the target texture, they are offset by
//   mEGLImageSourceAttributes.  This property holds for the source texture too, since these offsets
//   are zero.
//
// Before the backend accesses the backing image, it must use the |toOwner*()| helpers in
// TextureState/RenderbufferState to convert from the first set of types to |Owner*| types, where
// the EGL image level and layer offsets are applied, and finally |get()| the translated
// level/layer/image index to interface with the native API.  The backend |TextureBackend| object
// should strive to internally use |Owner*| types before translation to the native API, never
// gl::LevelIndex, gl::LayerIndex, or gl::ImageIndex directly to ensure translation is always done
// and done only once.

// Similar class to LevelIndex.  Notable difference is the default constructor which initializes to
// an invalid value; the fact that this level corresponds to the owner of the backing storage must
// always be explicit.
class OwnerLevel final
{
  public:
    constexpr OwnerLevel() : mLevel(0xFFFFFFFF) {}
    constexpr explicit OwnerLevel(uint32_t ownerLevel) : mLevel(ownerLevel) {}

    // Convenience helpers
    constexpr OwnerLevel operator+(uint32_t offset) const { return OwnerLevel(mLevel + offset); }
    constexpr uint32_t operator-(OwnerLevel other) const
    {
        ASSERT(mLevel >= other.mLevel);
        return mLevel - other.mLevel;
    }
    OwnerLevel &operator++()
    {
        ++mLevel;
        return *this;
    }
    constexpr bool operator<(const OwnerLevel &other) const { return mLevel < other.mLevel; }
    constexpr bool operator<=(const OwnerLevel &other) const { return mLevel <= other.mLevel; }
    constexpr bool operator>(const OwnerLevel &other) const { return mLevel > other.mLevel; }
    constexpr bool operator>=(const OwnerLevel &other) const { return mLevel >= other.mLevel; }
    constexpr bool operator==(const OwnerLevel &other) const { return mLevel == other.mLevel; }
    constexpr bool operator!=(const OwnerLevel &other) const { return mLevel != other.mLevel; }

    constexpr uint32_t get() const { return mLevel; }

  protected:
    uint32_t mLevel;
};
// Similar class to LayerIndex.  Notable difference is the default constructor which initializes to
// an invalid value; the fact that this layer corresponds to the owner of the backing storage must
// always be explicit.
class OwnerLayer final
{
  public:
    constexpr OwnerLayer() : mLayer(0xFFFFFFFF) {}
    constexpr explicit OwnerLayer(uint32_t ownerLayer) : mLayer(ownerLayer) {}

    // Convenience helpers
    constexpr OwnerLayer operator+(uint32_t offset) const { return OwnerLayer(mLayer + offset); }
    OwnerLayer &operator++()
    {
        ++mLayer;
        return *this;
    }

    constexpr bool operator<(const OwnerLayer &other) const { return mLayer < other.mLayer; }
    constexpr bool operator<=(const OwnerLayer &other) const { return mLayer <= other.mLayer; }
    constexpr bool operator>(const OwnerLayer &other) const { return mLayer > other.mLayer; }
    constexpr bool operator>=(const OwnerLayer &other) const { return mLayer >= other.mLayer; }
    constexpr bool operator==(const OwnerLayer &other) const { return mLayer == other.mLayer; }
    constexpr bool operator!=(const OwnerLayer &other) const { return mLayer != other.mLayer; }
    // Helper for loops up to "layer count"
    constexpr bool operator<(uint32_t limit) const { return mLayer < limit; }

    constexpr uint32_t get() const { return mLayer; }

  protected:
    uint32_t mLayer;
};
// Wrapper around |ImageIndex| to reuse its functionality.  Notable difference is that
// |getLayerIndex()| returns 0 if there are no layers, instead of -1 in |ImageIndex|, obviating the
// need for |index.hasLayer() ? index.getLayerIndex() : 0| in many places.
class OwnerImageIndex final
{
  public:
    OwnerImageIndex() = default;

    // Convenience helpers that forward to ImageIndex and possibly wrap the results.
    TextureType getType() const { return mIndex.getType(); }
    OwnerLevel getLevelIndex() const { return OwnerLevel(mIndex.getLevelIndex()); }
    bool hasLayer() const { return mIndex.hasLayer(); }
    bool has3DLayer() const { return mIndex.has3DLayer(); }
    OwnerLayer getLayerIndex() const
    {
        return OwnerLayer(mIndex.hasLayer() ? mIndex.getLayerIndex() : 0);
    }
    OwnerLayer cubeMapFaceIndex() const { return OwnerLayer(mIndex.cubeMapFaceIndex()); }
    uint32_t getLayerCount() const { return mIndex.getLayerCount(); }
    bool usesTex3D() const { return mIndex.usesTex3D(); }
    bool isLayered() const { return mIndex.isLayered(); }
    TextureTarget getTarget() const { return mIndex.getTarget(); }
    TextureTarget getTargetOrFirstCubeFace() const { return mIndex.getTargetOrFirstCubeFace(); }

    static OwnerImageIndex MakeInvalid() { return OwnerImageIndex(ImageIndex{}); }
    static OwnerImageIndex Make2D(OwnerLevel level)
    {
        return OwnerImageIndex(ImageIndex::Make2D(level.get()));
    }
    static OwnerImageIndex MakeCubeMapFace(TextureTarget target, OwnerLevel level)
    {
        return OwnerImageIndex(ImageIndex::MakeCubeMapFace(target, level.get()));
    }
    static OwnerImageIndex Make2DArrayRange(OwnerLevel level, OwnerLayer layer, GLint layerCount)
    {
        return OwnerImageIndex(ImageIndex::Make2DArrayRange(level.get(), layer.get(), layerCount));
    }
    static OwnerImageIndex Make3D(OwnerLevel level, OwnerLayer layer = kEntireLayer)
    {
        return OwnerImageIndex(ImageIndex::Make3D(level.get(), layer.get()));
    }
    static OwnerImageIndex MakeFromTarget(TextureTarget target, OwnerLevel level, GLint depth = 0)
    {
        return OwnerImageIndex(ImageIndex::MakeFromTarget(target, level.get(), depth));
    }
    static OwnerImageIndex MakeFromType(TextureType type,
                                        OwnerLevel level,
                                        OwnerLayer layer = kEntireLayer,
                                        GLint layerCount = 1)
    {
        return OwnerImageIndex(
            ImageIndex::MakeFromType(type, level.get(), layer.get(), layerCount));
    }

    bool operator<(const OwnerImageIndex &b) const { return mIndex < b.mIndex; }
    bool operator==(const OwnerImageIndex &b) const { return mIndex == b.mIndex; }
    bool operator!=(const OwnerImageIndex &b) const { return mIndex != b.mIndex; }

    const ImageIndex &get() const { return mIndex; }

    static constexpr OwnerLayer kEntireLayer = OwnerLayer(ImageIndex::kEntireLevel);

  protected:
    ImageIndex mIndex;
    friend struct egl::ImageSourceAttributes;
    OwnerImageIndex(const ImageIndex &index) : mIndex(index) {}
};

}  // namespace gl

#endif  // LIBANGLE_IMAGE_INDEX_H_