Metal: multiple bug fixes

src/libANGLE/renderer/metal/ContextMtl.mm

@@ -150,8 +150,8 @@ angle::Result ContextMtl::drawTriFanArraysWithBaseVertex(const gl::Context *cont
             context, {0, static_cast<uint32_t>(count), mTriFanArraysIndexBuffer, 0}));
     }
 
-    ANGLE_TRY(setupDraw(context, gl::PrimitiveMode::Triangles, first, genIndicesCount, 1,
-                        gl::DrawElementsType::UnsignedInt, reinterpret_cast<const void *>(0)));
+    ANGLE_TRY(setupDraw(context, gl::PrimitiveMode::TriangleFan, first, count, 1,
+                        gl::DrawElementsType::InvalidEnum, reinterpret_cast<const void *>(0)));
 
     // Draw with the zero starting index buffer, shift the vertex index using baseVertex instanced
     // draw:
@@ -173,9 +173,8 @@ angle::Result ContextMtl::drawTriFanArraysLegacy(const gl::Context *context,
         context, {static_cast<uint32_t>(first), static_cast<uint32_t>(count), genIdxBuffer,
                   genIdxBufferOffset}));
 
-    ANGLE_TRY(setupDraw(context, gl::PrimitiveMode::Triangles, 0, genIndicesCount, 1,
-                        gl::DrawElementsType::UnsignedInt,
-                        reinterpret_cast<const void *>(genIdxBufferOffset)));
+    ANGLE_TRY(setupDraw(context, gl::PrimitiveMode::TriangleFan, first, count, 1,
+                        gl::DrawElementsType::InvalidEnum, reinterpret_cast<const void *>(0)));
 
     mRenderEncoder.drawIndexed(MTLPrimitiveTypeTriangle, genIndicesCount, MTLIndexTypeUInt32,
                                genIdxBuffer, genIdxBufferOffset);
@@ -258,9 +257,7 @@ angle::Result ContextMtl::drawTriFanElements(const gl::Context *context,
 
         ANGLE_TRY(mTriFanIndexBuffer.commit(this));
 
-        ANGLE_TRY(setupDraw(context, gl::PrimitiveMode::Triangles, 0, genIndicesCount, 1,
-                            gl::DrawElementsType::UnsignedInt,
-                            reinterpret_cast<const void *>(genIdxBufferOffset)));
+        ANGLE_TRY(setupDraw(context, gl::PrimitiveMode::TriangleFan, 0, count, 1, type, indices));
 
         mRenderEncoder.drawIndexed(MTLPrimitiveTypeTriangle, genIndicesCount, MTLIndexTypeUInt32,
                                    genIdxBuffer, genIdxBufferOffset);

src/libANGLE/renderer/metal/FrameBufferMtl.h

@@ -95,6 +95,11 @@ class FramebufferMtl : public FramebufferImpl
     void onFinishedDrawingToFrameBuffer(const gl::Context *context,
                                         mtl::RenderCommandEncoder *encoder);
 
+    // The actual area will be adjusted based on framebuffer flipping property.
+    gl::Rectangle getReadPixelArea(const gl::Rectangle &glArea);
+
+    // NOTE: this method doesn't do the flipping of area. Caller must do it if needed before
+    // callling this. See getReadPixelsArea().
     angle::Result readPixelsImpl(const gl::Context *context,
                                  const gl::Rectangle &area,
                                  const PackPixelsParams &packPixelsParams,

src/libANGLE/renderer/metal/FrameBufferMtl.mm

@@ -188,11 +188,7 @@ angle::Result FramebufferMtl::readPixels(const gl::Context *context,
         // nothing to read
         return angle::Result::Continue;
     }
-    gl::Rectangle flippedArea = clippedArea;
-    if (mFlipY)
-    {
-        flippedArea.y = fbRect.height - flippedArea.y - flippedArea.height;
-    }
+    gl::Rectangle flippedArea = getReadPixelArea(clippedArea);
 
     ContextMtl *contextMtl              = mtl::GetImpl(context);
     const gl::State &glState            = context->getState();
@@ -673,6 +669,21 @@ angle::Result FramebufferMtl::invalidateImpl(ContextMtl *contextMtl,
     return angle::Result::Continue;
 }
 
+gl::Rectangle FramebufferMtl::getReadPixelArea(const gl::Rectangle &glArea)
+{
+    RenderTargetMtl *colorReadRT = getColorReadRenderTarget();
+    ASSERT(colorReadRT);
+    gl::Rectangle flippedArea = glArea;
+    if (mFlipY)
+    {
+        flippedArea.y =
+            colorReadRT->getTexture()->height(static_cast<uint32_t>(colorReadRT->getLevelIndex())) -
+            flippedArea.y - flippedArea.height;
+    }
+
+    return flippedArea;
+}
+
 angle::Result FramebufferMtl::readPixelsImpl(const gl::Context *context,
                                              const gl::Rectangle &area,
                                              const PackPixelsParams &packPixelsParams,

src/libANGLE/renderer/metal/SurfaceMtl.mm

@@ -263,6 +263,9 @@ egl::Error SurfaceMtl::initialize(const egl::Display *display)
 
             [mLayer addSublayer:mMetalLayer.get()];
         }
+
+        // ensure drawableSize is set to correct value:
+        checkIfLayerResized();
     }
 
     return egl::NoError();

src/libANGLE/renderer/metal/TextureMtl.mm

@@ -803,6 +803,7 @@ angle::Result TextureMtl::copySubImageWithDraw(const gl::Context *context,
     blitParams.dstColorMask = mTexture->getColorWritableMask();
 
     blitParams.src          = colorReadRT->getTexture();
+    blitParams.srcLevel     = static_cast<uint32_t>(colorReadRT->getLevelIndex());
     blitParams.srcRect      = clippedSourceArea;
     blitParams.srcYFlipped  = framebufferMtl->flipY();
     blitParams.dstLuminance = internalFormat.isLUMA();
@@ -827,7 +828,7 @@ angle::Result TextureMtl::copySubImageCPU(const gl::Context *context,
     angle::MemoryBuffer conversionRow;
     ANGLE_CHECK_GL_ALLOC(contextMtl, conversionRow.resize(dstRowPitch));
 
-    MTLRegion mtlDstRowArea  = MTLRegionMake2D(clippedSourceArea.x, 0, clippedSourceArea.width, 1);
+    MTLRegion mtlDstRowArea  = MTLRegionMake2D(modifiedDestOffset.x, 0, clippedSourceArea.width, 1);
     gl::Rectangle srcRowArea = gl::Rectangle(clippedSourceArea.x, 0, clippedSourceArea.width, 1);
 
     for (int r = 0; r < clippedSourceArea.height; ++r)
@@ -838,7 +839,8 @@ angle::Result TextureMtl::copySubImageCPU(const gl::Context *context,
         PackPixelsParams packParams(srcRowArea, dstFormat, dstRowPitch, false, nullptr, 0);
 
         // Read pixels from framebuffer to memory:
-        ANGLE_TRY(framebufferMtl->readPixelsImpl(context, srcRowArea, packParams,
+        gl::Rectangle flippedSrcRowArea = framebufferMtl->getReadPixelArea(srcRowArea);
+        ANGLE_TRY(framebufferMtl->readPixelsImpl(context, flippedSrcRowArea, packParams,
                                                  framebufferMtl->getColorReadRenderTarget(),
                                                  conversionRow.data()));
 

src/libANGLE/renderer/metal/mtl_render_utils.mm

@@ -605,7 +605,7 @@ AutoObjCPtr<id<MTLComputePipelineState>> RenderUtils::getTriFanFromElemArrayGene
 
     IndexConvesionPipelineCacheKey key = {srcType, aligned};
 
-    auto &cache = mIndexConversionPipelineCaches[key];
+    auto &cache = mTriFanFromElemArrayGeneratorPipelineCaches[key];
 
     if (!cache)
     {

src/libANGLE/renderer/metal/mtl_resources.mm

@@ -161,48 +161,54 @@ Texture::Texture(ContextMtl *context,
                  bool renderTargetOnly,
                  bool supportTextureView)
 {
-    id<MTLDevice> metalDevice = context->getMetalDevice();
-
-    if (mips > 1 && mips < desc.mipmapLevelCount)
+    ANGLE_MTL_OBJC_SCOPE
     {
-        desc.mipmapLevelCount = mips;
-    }
+        id<MTLDevice> metalDevice = context->getMetalDevice();
 
-    // Every texture will support being rendered for now
-    desc.usage = 0;
+        if (mips > 1 && mips < desc.mipmapLevelCount)
+        {
+            desc.mipmapLevelCount = mips;
+        }
 
-    if (Format::FormatRenderable(desc.pixelFormat))
-    {
-        desc.usage |= MTLTextureUsageRenderTarget;
-    }
+        // Every texture will support being rendered for now
+        desc.usage = 0;
 
-    if (!Format::FormatCPUReadable(desc.pixelFormat))
-    {
-        desc.resourceOptions = MTLResourceStorageModePrivate;
-    }
+        if (Format::FormatRenderable(desc.pixelFormat))
+        {
+            desc.usage |= MTLTextureUsageRenderTarget;
+        }
 
-    if (!renderTargetOnly)
-    {
-        desc.usage = desc.usage | MTLTextureUsageShaderRead;
-    }
+        if (!Format::FormatCPUReadable(desc.pixelFormat))
+        {
+            desc.resourceOptions = MTLResourceStorageModePrivate;
+        }
 
-    if (supportTextureView)
-    {
-        desc.usage = desc.usage | MTLTextureUsagePixelFormatView;
-    }
+        if (!renderTargetOnly)
+        {
+            desc.usage = desc.usage | MTLTextureUsageShaderRead;
+        }
 
-    set([metalDevice newTextureWithDescriptor:desc]);
+        if (supportTextureView)
+        {
+            desc.usage = desc.usage | MTLTextureUsagePixelFormatView;
+        }
+
+        set([[metalDevice newTextureWithDescriptor:desc] ANGLE_MTL_AUTORELEASE]);
+    }
 }
 
 Texture::Texture(Texture *original, MTLTextureType type, NSRange mipmapLevelRange, uint32_t slice)
     : Resource(original)
 {
-    auto view = [original->get() newTextureViewWithPixelFormat:original->pixelFormat()
-                                                   textureType:type
-                                                        levels:mipmapLevelRange
-                                                        slices:NSMakeRange(slice, 1)];
+    ANGLE_MTL_OBJC_SCOPE
+    {
+        auto view = [original->get() newTextureViewWithPixelFormat:original->pixelFormat()
+                                                       textureType:type
+                                                            levels:mipmapLevelRange
+                                                            slices:NSMakeRange(slice, 1)];
 
-    set(view);
+        set([view ANGLE_MTL_AUTORELEASE]);
+    }
 }
 
 void Texture::syncContent(ContextMtl *context)
@@ -380,7 +386,7 @@ angle::Result Buffer::reset(ContextMtl *context, size_t size, const uint8_t *dat
             newBuffer = [metalDevice newBufferWithLength:size options:options];
         }
 
-        set(newBuffer);
+        set([newBuffer ANGLE_MTL_AUTORELEASE]);
 
         return angle::Result::Continue;
     }

src/libANGLE/renderer/metal/mtl_utils.mm

@@ -99,7 +99,7 @@ MTLViewport GetViewportFlipY(const gl::Rectangle &rect,
     MTLViewport re;
 
     re.originX = rect.x;
-    re.originY = screenHeight - rect.y1();
+    re.originY = static_cast<double>(screenHeight) - rect.y1();
     re.width   = rect.width;
     re.height  = rect.height;
     re.znear   = znear;