Implemented mipmap generation for 2D array textures.

src/libGLESv2/Texture.cpp

@@ -2128,7 +2128,35 @@ void Texture2DArray::storage(GLsizei levels, GLenum internalformat, GLsizei widt
 
 void Texture2DArray::generateMipmaps()
 {
-    UNIMPLEMENTED();
+    // Purge array levels 1 through q and reset them to represent the generated mipmap levels.
+    int q = log2(std::max(getWidth(0), getHeight(0)));
+    for (int i = 1; i <= q; i++)
+    {
+        redefineImage(i, getInternalFormat(0), std::max(getWidth(0) >> i, 1), std::max(getHeight(0) >> i, 1), getDepth(0));
+    }
+
+    if (mTexStorage && mTexStorage->isRenderTarget())
+    {
+        for (int level = 1; level <= q; level++)
+        {
+            mTexStorage->generateMipmap(level);
+
+            for (int layer = 0; layer < mLayerCounts[level]; layer++)
+            {
+                mImageArray[level][layer]->markClean();
+            }
+        }
+    }
+    else
+    {
+        for (int level = 1; level <= q; level++)
+        {
+            for (int layer = 0; layer < mLayerCounts[level]; layer++)
+            {
+                mRenderer->generateMipmap(mImageArray[level][layer], mImageArray[level - 1][layer]);
+            }
+        }
+    }
 }
 
 void Texture2DArray::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)

src/libGLESv2/libGLESv2.cpp

@@ -3201,6 +3201,23 @@ void __stdcall glGenerateMipmap(GLenum target)
                     break;
                 }
 
+                case GL_TEXTURE_2D_ARRAY:
+                  {
+                      if (context->getClientVersion() < 3)
+                      {
+                          return gl::error(GL_INVALID_ENUM);
+                      }
+
+                      gl::Texture2DArray *tex2darr = context->getTexture2DArray();
+                      if (tex2darr->isCompressed(0))
+                      {
+                          return gl::error(GL_INVALID_OPERATION);
+                      }
+
+                      tex2darr->generateMipmaps();
+                      break;
+                  }
+
               default:
                 return gl::error(GL_INVALID_ENUM);
             }

src/libGLESv2/renderer/TextureStorage11.cpp

@@ -987,8 +987,22 @@ RenderTarget *TextureStorage11_2DArray::getRenderTargetLayer(int mipLevel, int l
             ID3D11Device *device = mRenderer->getDevice();
             HRESULT result;
 
-            // TODO, what kind of SRV is expected here?
-            ID3D11ShaderResourceView *srv = NULL;
+            D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
+            srvDesc.Format = mShaderResourceFormat;
+            srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
+            srvDesc.Texture2DArray.MostDetailedMip = mipLevel;
+            srvDesc.Texture2DArray.MipLevels = 1;
+            srvDesc.Texture2DArray.FirstArraySlice = layer;
+            srvDesc.Texture2DArray.ArraySize = 1;
+
+            ID3D11ShaderResourceView *srv;
+            result = device->CreateShaderResourceView(mTexture, &srvDesc, &srv);
+
+            if (result == E_OUTOFMEMORY)
+            {
+                return gl::error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+            }
+            ASSERT(SUCCEEDED(result));
 
             if (mRenderTargetFormat != DXGI_FORMAT_UNKNOWN)
             {
@@ -1033,7 +1047,13 @@ RenderTarget *TextureStorage11_2DArray::getRenderTargetLayer(int mipLevel, int l
 
 void TextureStorage11_2DArray::generateMipmap(int level)
 {
-    UNIMPLEMENTED();
+    for (unsigned int layer = 0; layer < mTextureDepth; layer++)
+    {
+        RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTargetLayer(level - 1, layer));
+        RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTargetLayer(level, layer));
+
+        generateMipmapLayer(source, dest);
+    }
 }
 
 }