commit cc129377530b25d4d2b1c67e8f3ad49869ca8dba
author Jamie Madill <jmadill@chromium.org> Thu Apr 12 09:13:18 2018 -0400
committer Commit Bot <commit-bot@chromium.org> Thu Apr 12 23:08:07 2018 +0000
tree 77c2ee399d758355db17a4b0c5deadd484eb6ba8
parent ed8d5ec7333070baddc731babbca895537a73cf4

ImageIndex: Consolidate layer/cube face.

In terms of the Texture or Image resource, a cube face
refers to a layer of a 2D texture. This layer has a special
meaning for cube textures, but it is represented as a layer
with a layer index. Cube array textures are no different,
they just use a different indexing scheme for the array
layers.

This also cleans up the ImageIndex helper to have a class
structure with private data, and cleans up a few cases to
use generic Make functions and iterators where they were
setting properties of the index directly.

This will make it easier to have ImageIndexes address
entire levels of a Cube map in the future, and makes the
layer count logic in Vulkan cleaner.

Bug: angleproject:2318
Change-Id: Iea9842e233f974a9896282ca224cb001f7882bd1
Reviewed-on: https://chromium-review.googlesource.com/987525
Reviewed-by: Luc Ferron <lucferron@chromium.org>
Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>

src/libANGLE/ImageIndexIterator_unittest.cpp

diff --git a/src/libANGLE/ImageIndexIterator_unittest.cpp b/src/libANGLE/ImageIndexIterator_unittest.cpp
index 2b656e2..9ffb195 100644
--- a/src/libANGLE/ImageIndexIterator_unittest.cpp
+++ b/src/libANGLE/ImageIndexIterator_unittest.cpp
@@ -32,15 +32,16 @@
         ImageIndex current = iter.current();
         ImageIndex nextIndex = iter.next();
 
-        EXPECT_EQ(TextureType::_2D, nextIndex.type);
-        EXPECT_EQ(TextureTarget::_2D, nextIndex.target);
-        EXPECT_EQ(mip, nextIndex.mipIndex);
+        EXPECT_EQ(TextureType::_2D, nextIndex.getType());
+        EXPECT_EQ(TextureTarget::_2D, nextIndex.getTarget());
+        EXPECT_EQ(mip, nextIndex.getLevelIndex());
         EXPECT_FALSE(nextIndex.hasLayer());
+        EXPECT_FALSE(nextIndex.has3DLayer());
 
         // Also test current
-        EXPECT_EQ(current.type, nextIndex.type);
-        EXPECT_EQ(current.mipIndex, nextIndex.mipIndex);
-        EXPECT_EQ(current.layerIndex, nextIndex.layerIndex);
+        EXPECT_EQ(current.getType(), nextIndex.getType());
+        EXPECT_EQ(current.getLevelIndex(), nextIndex.getLevelIndex());
+        EXPECT_EQ(current.getLayerIndex(), nextIndex.getLayerIndex());
     }
 
     EXPECT_FALSE(iter.hasNext());
@@ -59,10 +60,11 @@
             EXPECT_TRUE(iter.hasNext());
             ImageIndex nextIndex = iter.next();
 
-            EXPECT_EQ(TextureType::CubeMap, nextIndex.type);
-            EXPECT_EQ(target, nextIndex.target);
-            EXPECT_EQ(mip, nextIndex.mipIndex);
-            EXPECT_FALSE(nextIndex.hasLayer());
+            EXPECT_EQ(TextureType::CubeMap, nextIndex.getType());
+            EXPECT_EQ(target, nextIndex.getTarget());
+            EXPECT_EQ(mip, nextIndex.getLevelIndex());
+            EXPECT_TRUE(nextIndex.hasLayer());
+            EXPECT_FALSE(nextIndex.has3DLayer());
         }
     }
 
@@ -82,11 +84,12 @@
             EXPECT_TRUE(iter.hasNext());
             ImageIndex nextIndex = iter.next();
 
-            EXPECT_EQ(TextureType::_3D, nextIndex.type);
-            EXPECT_EQ(TextureTarget::_3D, nextIndex.target);
-            EXPECT_EQ(mip, nextIndex.mipIndex);
-            EXPECT_EQ(layer, nextIndex.layerIndex);
+            EXPECT_EQ(TextureType::_3D, nextIndex.getType());
+            EXPECT_EQ(TextureTarget::_3D, nextIndex.getTarget());
+            EXPECT_EQ(mip, nextIndex.getLevelIndex());
+            EXPECT_EQ(layer, nextIndex.getLayerIndex());
             EXPECT_TRUE(nextIndex.hasLayer());
+            EXPECT_TRUE(nextIndex.has3DLayer());
         }
     }
 
@@ -109,15 +112,47 @@
             EXPECT_TRUE(iter.hasNext());
             ImageIndex nextIndex = iter.next();
 
-            EXPECT_EQ(TextureType::_2DArray, nextIndex.type);
-            EXPECT_EQ(TextureTarget::_2DArray, nextIndex.target);
-            EXPECT_EQ(mip, nextIndex.mipIndex);
-            EXPECT_EQ(layer, nextIndex.layerIndex);
+            EXPECT_EQ(TextureType::_2DArray, nextIndex.getType());
+            EXPECT_EQ(TextureTarget::_2DArray, nextIndex.getTarget());
+            EXPECT_EQ(mip, nextIndex.getLevelIndex());
+            EXPECT_EQ(layer, nextIndex.getLayerIndex());
             EXPECT_TRUE(nextIndex.hasLayer());
+            EXPECT_TRUE(nextIndex.has3DLayer());
         }
     }
 
     EXPECT_FALSE(iter.hasNext());
 }
 
+TEST(ImageIndexTest, LayerIterator2DArray)
+{
+    GLsizei layerCounts[] = {1, 3, 5, 2};
+
+    ASSERT_GE(0, minMip);
+    ASSERT_EQ(ArraySize(layerCounts), static_cast<size_t>(maxMip));
+
+    for (GLint mip = minMip; mip < maxMip; mip++)
+    {
+        // Make a layer iterator.
+        ImageIndex mipImageIndex = ImageIndex::Make2DArray(mip, ImageIndex::kEntireLevel);
+        ImageIndexIterator iter  = mipImageIndex.getLayerIterator(layerCounts[mip]);
+
+        for (GLint layer = 0; layer < layerCounts[mip]; layer++)
+        {
+            EXPECT_TRUE(iter.hasNext());
+            ImageIndex nextIndex = iter.next();
+
+            EXPECT_EQ(TextureType::_2DArray, nextIndex.getType());
+            EXPECT_EQ(TextureTarget::_2DArray, nextIndex.getTarget());
+            EXPECT_EQ(mip, nextIndex.getLevelIndex());
+            EXPECT_EQ(layer, nextIndex.getLayerIndex());
+            EXPECT_TRUE(nextIndex.hasLayer());
+            EXPECT_TRUE(nextIndex.has3DLayer());
+            EXPECT_LT(nextIndex.getLayerIndex(), layerCounts[mip]);
+        }
+
+        EXPECT_FALSE(iter.hasNext());
+    }
+}
+
 } // namespace