blob: 07bb3291a99ee51a029264fab8f48d15edfb46da [file] [log] [blame]
//
// 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 "common/utilities.h"
#include "libANGLE/Constants.h"
#include "libANGLE/angletypes.h"
#include <tuple>
namespace gl
{
namespace
{
GLint TextureTargetToLayer(TextureTarget target)
{
switch (target)
{
case TextureTarget::CubeMapPositiveX:
return 0;
case TextureTarget::CubeMapNegativeX:
return 1;
case TextureTarget::CubeMapPositiveY:
return 2;
case TextureTarget::CubeMapNegativeY:
return 3;
case TextureTarget::CubeMapPositiveZ:
return 4;
case TextureTarget::CubeMapNegativeZ:
return 5;
case TextureTarget::External:
return ImageIndex::kEntireLevel;
case TextureTarget::Rectangle:
return ImageIndex::kEntireLevel;
case TextureTarget::_2D:
return ImageIndex::kEntireLevel;
case TextureTarget::VideoImage:
return ImageIndex::kEntireLevel;
case TextureTarget::_2DArray:
return ImageIndex::kEntireLevel;
case TextureTarget::_2DMultisample:
return ImageIndex::kEntireLevel;
case TextureTarget::_2DMultisampleArray:
return ImageIndex::kEntireLevel;
case TextureTarget::_3D:
return ImageIndex::kEntireLevel;
default:
UNREACHABLE();
return 0;
}
}
bool IsArrayTarget(TextureTarget target)
{
switch (target)
{
case TextureTarget::_2DArray:
case TextureTarget::_2DMultisampleArray:
return true;
default:
return false;
}
}
} // anonymous namespace
TextureTarget TextureTypeToTarget(TextureType type, GLint layerIndex)
{
if (type == TextureType::CubeMap)
{
// As GL_TEXTURE_CUBE_MAP cannot be a texture target in texImage*D APIs, so we don't allow
// an entire cube map to have a texture target.
ASSERT(layerIndex != ImageIndex::kEntireLevel);
return CubeFaceIndexToTextureTarget(layerIndex);
}
else
{
return NonCubeTextureTypeToTarget(type);
}
}
ImageIndex::ImageIndex()
: mType(TextureType::InvalidEnum), mLevelIndex(0), mLayerIndex(0), mLayerCount(kEntireLevel)
{}
ImageIndex::ImageIndex(const ImageIndex &other) = default;
ImageIndex &ImageIndex::operator=(const ImageIndex &other) = default;
bool ImageIndex::hasLayer() const
{
return mLayerIndex != kEntireLevel;
}
bool ImageIndex::isLayered() const
{
switch (mType)
{
case TextureType::_2DArray:
case TextureType::_2DMultisampleArray:
case TextureType::CubeMap:
case TextureType::_3D:
return mLayerIndex == kEntireLevel;
default:
return false;
}
}
bool ImageIndex::has3DLayer() const
{
// It's quicker to check != CubeMap than calling usesTex3D, which checks multiple types. This
// ASSERT validates the check gives the same result.
ASSERT(!hasLayer() || ((mType != TextureType::CubeMap) == usesTex3D()));
return (hasLayer() && mType != TextureType::CubeMap);
}
bool ImageIndex::usesTex3D() const
{
return mType == TextureType::_3D || mType == TextureType::_2DArray ||
mType == TextureType::_2DMultisampleArray;
}
TextureTarget ImageIndex::getTarget() const
{
return TextureTypeToTarget(mType, mLayerIndex);
}
gl::TextureTarget ImageIndex::getTargetOrFirstCubeFace() const
{
if (isEntireLevelCubeMap())
{
return gl::kCubeMapTextureTargetMin;
}
else
{
return getTarget();
}
}
GLint ImageIndex::cubeMapFaceIndex() const
{
ASSERT(mType == TextureType::CubeMap);
ASSERT(mLayerIndex == kEntireLevel || mLayerIndex < static_cast<GLint>(kCubeFaceCount));
return mLayerIndex;
}
bool ImageIndex::valid() const
{
return mType != TextureType::InvalidEnum;
}
bool ImageIndex::isEntireLevelCubeMap() const
{
return mType == TextureType::CubeMap && mLayerIndex == ImageIndex::kEntireLevel;
}
ImageIndex ImageIndex::Make2D(GLint levelIndex)
{
return ImageIndex(TextureType::_2D, levelIndex, kEntireLevel, 1);
}
ImageIndex ImageIndex::MakeRectangle(GLint levelIndex)
{
return ImageIndex(TextureType::Rectangle, levelIndex, kEntireLevel, 1);
}
ImageIndex ImageIndex::MakeCubeMapFace(TextureTarget target, GLint levelIndex)
{
ASSERT(IsCubeMapFaceTarget(target));
return ImageIndex(TextureType::CubeMap, levelIndex, TextureTargetToLayer(target), 1);
}
ImageIndex ImageIndex::Make2DArray(GLint levelIndex, GLint layerIndex)
{
return ImageIndex(TextureType::_2DArray, levelIndex, layerIndex, 1);
}
ImageIndex ImageIndex::Make2DArrayRange(GLint levelIndex, GLint layerIndex, GLint numLayers)
{
return ImageIndex(TextureType::_2DArray, levelIndex, layerIndex, numLayers);
}
ImageIndex ImageIndex::Make3D(GLint levelIndex, GLint layerIndex)
{
return ImageIndex(TextureType::_3D, levelIndex, layerIndex, 1);
}
ImageIndex ImageIndex::MakeFromTarget(TextureTarget target, GLint levelIndex, GLint depth)
{
return ImageIndex(TextureTargetToType(target), levelIndex, TextureTargetToLayer(target),
IsArrayTarget(target) ? depth : 1);
}
ImageIndex ImageIndex::MakeFromType(TextureType type,
GLint levelIndex,
GLint layerIndex,
GLint layerCount)
{
GLint overrideLayerCount =
(type == TextureType::CubeMap && layerIndex == kEntireLevel ? kCubeFaceCount : layerCount);
return ImageIndex(type, levelIndex, layerIndex, overrideLayerCount);
}
ImageIndex ImageIndex::Make2DMultisample()
{
return ImageIndex(TextureType::_2DMultisample, 0, kEntireLevel, 1);
}
ImageIndex ImageIndex::Make2DMultisampleArray(GLint layerIndex)
{
return ImageIndex(TextureType::_2DMultisampleArray, 0, layerIndex, 1);
}
ImageIndex ImageIndex::Make2DMultisampleArrayRange(GLint layerIndex, GLint numLayers)
{
return ImageIndex(TextureType::_2DMultisampleArray, 0, layerIndex, numLayers);
}
bool ImageIndex::operator<(const ImageIndex &b) const
{
return std::tie(mType, mLevelIndex, mLayerIndex, mLayerCount) <
std::tie(b.mType, b.mLevelIndex, b.mLayerIndex, b.mLayerCount);
}
bool ImageIndex::operator==(const ImageIndex &b) const
{
return std::tie(mType, mLevelIndex, mLayerIndex, mLayerCount) ==
std::tie(b.mType, b.mLevelIndex, b.mLayerIndex, b.mLayerCount);
}
bool ImageIndex::operator!=(const ImageIndex &b) const
{
return !(*this == b);
}
ImageIndex::ImageIndex(TextureType type, GLint levelIndex, GLint layerIndex, GLint layerCount)
: mType(type), mLevelIndex(levelIndex), mLayerIndex(layerIndex), mLayerCount(layerCount)
{}
ImageIndexIterator ImageIndex::getLayerIterator(GLint layerCount) const
{
ASSERT(mType != TextureType::_2D && !hasLayer());
return ImageIndexIterator::MakeGeneric(mType, mLevelIndex, mLevelIndex + 1, 0, layerCount);
}
ImageIndexIterator::ImageIndexIterator(const ImageIndexIterator &other) = default;
ImageIndexIterator ImageIndexIterator::Make2D(GLint minMip, GLint maxMip)
{
return ImageIndexIterator(TextureType::_2D, Range<GLint>(minMip, maxMip),
Range<GLint>(ImageIndex::kEntireLevel, ImageIndex::kEntireLevel),
nullptr);
}
ImageIndexIterator ImageIndexIterator::MakeRectangle(GLint minMip, GLint maxMip)
{
return ImageIndexIterator(TextureType::Rectangle, Range<GLint>(minMip, maxMip),
Range<GLint>(ImageIndex::kEntireLevel, ImageIndex::kEntireLevel),
nullptr);
}
ImageIndexIterator ImageIndexIterator::MakeCube(GLint minMip, GLint maxMip)
{
return ImageIndexIterator(TextureType::CubeMap, Range<GLint>(minMip, maxMip),
Range<GLint>(0, 6), nullptr);
}
ImageIndexIterator ImageIndexIterator::Make3D(GLint minMip,
GLint maxMip,
GLint minLayer,
GLint maxLayer)
{
return ImageIndexIterator(TextureType::_3D, Range<GLint>(minMip, maxMip),
Range<GLint>(minLayer, maxLayer), nullptr);
}
ImageIndexIterator ImageIndexIterator::Make2DArray(GLint minMip,
GLint maxMip,
const GLsizei *layerCounts)
{
return ImageIndexIterator(TextureType::_2DArray, Range<GLint>(minMip, maxMip),
Range<GLint>(0, IMPLEMENTATION_MAX_2D_ARRAY_TEXTURE_LAYERS),
layerCounts);
}
ImageIndexIterator ImageIndexIterator::Make2DMultisample()
{
return ImageIndexIterator(TextureType::_2DMultisample, Range<GLint>(0, 1),
Range<GLint>(ImageIndex::kEntireLevel, ImageIndex::kEntireLevel),
nullptr);
}
ImageIndexIterator ImageIndexIterator::Make2DMultisampleArray(const GLsizei *layerCounts)
{
return ImageIndexIterator(TextureType::_2DMultisampleArray, Range<GLint>(0, 1),
Range<GLint>(0, IMPLEMENTATION_MAX_2D_ARRAY_TEXTURE_LAYERS),
layerCounts);
}
ImageIndexIterator ImageIndexIterator::MakeGeneric(TextureType type,
GLint minMip,
GLint maxMip,
GLint minLayer,
GLint maxLayer)
{
if (type == TextureType::CubeMap)
{
return MakeCube(minMip, maxMip);
}
return ImageIndexIterator(type, Range<GLint>(minMip, maxMip), Range<GLint>(minLayer, maxLayer),
nullptr);
}
ImageIndexIterator::ImageIndexIterator(TextureType type,
const Range<GLint> &mipRange,
const Range<GLint> &layerRange,
const GLsizei *layerCounts)
: mMipRange(mipRange),
mLayerRange(layerRange),
mLayerCounts(layerCounts),
mCurrentIndex(type, mipRange.low(), layerRange.low(), 1)
{}
GLint ImageIndexIterator::maxLayer() const
{
if (mLayerCounts)
{
ASSERT(mCurrentIndex.hasLayer());
return (mCurrentIndex.getLevelIndex() < mMipRange.high())
? mLayerCounts[mCurrentIndex.getLevelIndex()]
: 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.
if (mCurrentIndex.hasLayer() && mCurrentIndex.getLayerIndex() < maxLayer() - 1)
{
mCurrentIndex.mLayerIndex++;
}
else if (mCurrentIndex.mLevelIndex < mMipRange.high() - 1)
{
mCurrentIndex.mLayerIndex = mLayerRange.low();
mCurrentIndex.mLevelIndex++;
}
else
{
mCurrentIndex = ImageIndex();
}
return previousIndex;
}
ImageIndex ImageIndexIterator::current() const
{
return mCurrentIndex;
}
bool ImageIndexIterator::hasNext() const
{
return mCurrentIndex.valid();
}
} // namespace gl