ImageIndex.cpp

Branch :
Show log
Commit
Author : Corentin Wallez
Date : 2018-02-27 15:17:10
Hash : 99d492c2
Message : Use packed enums for the texture types and targets, part 2 This completes the refactor by using the packed enums in the gl:: layer and in the backends. The packed enum code generation is modified to support explicitly assigning values to the packed enums so that the TextureTarget cube map faces are in the correct order and easy to iterate over. BUG=angleproject:2169 Change-Id: I5903235e684ccf382e92a8a1e10c5c85b4b16a04 Reviewed-on: https://chromium-review.googlesource.com/939994 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org>
src/libANGLE/ImageIndex.cpp
#include "ImageIndex.h"
//
// 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.cpp: Implementation for ImageIndex methods.

#include "libANGLE/ImageIndex.h"
#include "libANGLE/Constants.h"
#include "common/utilities.h"

#include <tuple>

namespace gl
{

ImageIndex::ImageIndex(const ImageIndex &other) = default;
ImageIndex &ImageIndex::operator=(const ImageIndex &other) = default;

bool ImageIndex::is3D() const
{
    return type == TextureType::_3D || type == TextureType::_2DArray;
}

GLint ImageIndex::cubeMapFaceIndex() const
{
    ASSERT(type == TextureType::CubeMap);
    ASSERT(TextureTargetToType(target) == TextureType::CubeMap);
    return static_cast<GLint>(CubeMapTextureTargetToFaceIndex(target));
}

bool ImageIndex::valid() const
{
    return type != TextureType::InvalidEnum;
}

ImageIndex ImageIndex::Make2D(GLint mipIndex)
{
    return ImageIndex(TextureType::_2D, TextureTarget::_2D, mipIndex, ENTIRE_LEVEL, 1);
}

ImageIndex ImageIndex::MakeRectangle(GLint mipIndex)
{
    return ImageIndex(TextureType::Rectangle, TextureTarget::Rectangle, mipIndex, ENTIRE_LEVEL, 1);
}

ImageIndex ImageIndex::MakeCube(TextureTarget target, GLint mipIndex)
{
    ASSERT(TextureTargetToType(target) == TextureType::CubeMap);
    return ImageIndex(TextureType::CubeMap, target, mipIndex, ENTIRE_LEVEL, 1);
}

ImageIndex ImageIndex::Make2DArray(GLint mipIndex, GLint layerIndex)
{
    return ImageIndex(TextureType::_2DArray, TextureTarget::_2DArray, mipIndex, layerIndex, 1);
}

ImageIndex ImageIndex::Make2DArrayRange(GLint mipIndex, GLint layerIndex, GLint numLayers)
{
    return ImageIndex(TextureType::_2DArray, TextureTarget::_2DArray, mipIndex, layerIndex,
                      numLayers);
}

ImageIndex ImageIndex::Make3D(GLint mipIndex, GLint layerIndex)
{
    return ImageIndex(TextureType::_3D, TextureTarget::_3D, mipIndex, layerIndex, 1);
}

ImageIndex ImageIndex::MakeGeneric(TextureTarget target, GLint mipIndex)
{
    return ImageIndex(TextureTargetToType(target), target, mipIndex, ENTIRE_LEVEL, 1);
}

ImageIndex ImageIndex::Make2DMultisample()
{
    return ImageIndex(TextureType::_2DMultisample, TextureTarget::_2DMultisample, 0, ENTIRE_LEVEL,
                      1);
}

ImageIndex ImageIndex::MakeInvalid()
{
    return ImageIndex(TextureType::InvalidEnum, TextureTarget::InvalidEnum, -1, -1, -1);
}

bool operator<(const ImageIndex &a, const ImageIndex &b)
{
    return std::tie(a.type, a.target, a.mipIndex, a.layerIndex, a.numLayers) <
           std::tie(b.type, b.target, b.mipIndex, b.layerIndex, b.numLayers);
}

bool operator==(const ImageIndex &a, const ImageIndex &b)
{
    return std::tie(a.type, a.target, a.mipIndex, a.layerIndex, a.numLayers) ==
           std::tie(b.type, b.target, b.mipIndex, b.layerIndex, b.numLayers);
}

bool operator!=(const ImageIndex &a, const ImageIndex &b)
{
    return !(a == b);
}

ImageIndex::ImageIndex(TextureType typeIn,
                       TextureTarget targetIn,
                       GLint mipIndexIn,
                       GLint layerIndexIn,
                       GLint numLayersIn)
    : type(typeIn),
      target(targetIn),
      mipIndex(mipIndexIn),
      layerIndex(layerIndexIn),
      numLayers(numLayersIn)
{}

ImageIndexIterator::ImageIndexIterator(const ImageIndexIterator &other) = default;

ImageIndexIterator ImageIndexIterator::Make2D(GLint minMip, GLint maxMip)
{
    return ImageIndexIterator(
        TextureType::_2D, TextureTarget::_2D, TextureTarget::_2D, Range<GLint>(minMip, maxMip),
        Range<GLint>(ImageIndex::ENTIRE_LEVEL, ImageIndex::ENTIRE_LEVEL), nullptr);
}

ImageIndexIterator ImageIndexIterator::MakeRectangle(GLint minMip, GLint maxMip)
{
    return ImageIndexIterator(TextureType::Rectangle, TextureTarget::Rectangle,
                              TextureTarget::Rectangle, Range<GLint>(minMip, maxMip),
                              Range<GLint>(ImageIndex::ENTIRE_LEVEL, ImageIndex::ENTIRE_LEVEL),
                              nullptr);
}

ImageIndexIterator ImageIndexIterator::MakeCube(GLint minMip, GLint maxMip)
{
    return ImageIndexIterator(TextureType::CubeMap, kFirstCubeMapTextureTarget,
                              kLastCubeMapTextureTarget, Range<GLint>(minMip, maxMip),
                              Range<GLint>(ImageIndex::ENTIRE_LEVEL, ImageIndex::ENTIRE_LEVEL),
                              nullptr);
}

ImageIndexIterator ImageIndexIterator::Make3D(GLint minMip, GLint maxMip,
                                              GLint minLayer, GLint maxLayer)
{
    return ImageIndexIterator(TextureType::_3D, TextureTarget::_3D, TextureTarget::_3D,
                              Range<GLint>(minMip, maxMip), Range<GLint>(minLayer, maxLayer),
                              nullptr);
}

ImageIndexIterator ImageIndexIterator::Make2DArray(GLint minMip, GLint maxMip,
                                                   const GLsizei *layerCounts)
{
    return ImageIndexIterator(TextureType::_2DArray, TextureTarget::_2DArray,
                              TextureTarget::_2DArray, Range<GLint>(minMip, maxMip),
                              Range<GLint>(0, IMPLEMENTATION_MAX_2D_ARRAY_TEXTURE_LAYERS),
                              layerCounts);
}

ImageIndexIterator ImageIndexIterator::Make2DMultisample()
{
    return ImageIndexIterator(TextureType::_2DMultisample, TextureTarget::_2DMultisample,
                              TextureTarget::_2DMultisample, Range<GLint>(0, 0),
                              Range<GLint>(ImageIndex::ENTIRE_LEVEL, ImageIndex::ENTIRE_LEVEL),
                              nullptr);
}

ImageIndexIterator::ImageIndexIterator(TextureType type,
                                       angle::EnumIterator<TextureTarget> targetLow,
                                       angle::EnumIterator<TextureTarget> targetHigh,
                                       const Range<GLint> &mipRange,
                                       const Range<GLint> &layerRange,
                                       const GLsizei *layerCounts)
    : mTargetLow(targetLow),
      mTargetHigh(targetHigh),
      mMipRange(mipRange),
      mLayerRange(layerRange),
      mLayerCounts(layerCounts),
      mCurrentIndex(type, *targetLow, mipRange.low(), layerRange.low(), 1)
{}

GLint ImageIndexIterator::maxLayer() const
{
    if (mLayerCounts)
    {
        ASSERT(mCurrentIndex.hasLayer());
        return (mCurrentIndex.mipIndex < mMipRange.high()) ? mLayerCounts[mCurrentIndex.mipIndex]
                                                           : 0;
    }
    return mLayerRange.high();
}

ImageIndex ImageIndexIterator::next()
{
    ASSERT(hasNext());

    // Make a copy of the current index to return
    ImageIndex previousIndex = mCurrentIndex;

    // Iterate layers in the inner loop for now. We can add switchable
    // layer or mip iteration if we need it.

    angle::EnumIterator<TextureTarget> currentTarget = mCurrentIndex.target;
    if (currentTarget != mTargetHigh)
    {
        ++currentTarget;
        mCurrentIndex.target = *currentTarget;
    }
    else if (mCurrentIndex.hasLayer() && mCurrentIndex.layerIndex < maxLayer() - 1)
    {
        mCurrentIndex.target = *mTargetLow;
        mCurrentIndex.layerIndex++;
    }
    else if (mCurrentIndex.mipIndex < mMipRange.high() - 1)
    {
        mCurrentIndex.target     = *mTargetLow;
        mCurrentIndex.layerIndex = mLayerRange.low();
        mCurrentIndex.mipIndex++;
    }
    else
    {
        mCurrentIndex = ImageIndex::MakeInvalid();
    }

    return previousIndex;
}

ImageIndex ImageIndexIterator::current() const
{
    return mCurrentIndex;
}

bool ImageIndexIterator::hasNext() const
{
    return mCurrentIndex.valid();
}

}  // namespace gl
kc3-lang/angle/src/libANGLE/ImageIndex.cpp

Commit

kc3-lang/angle /src/libANGLE/ImageIndex.cpp
