Turn on full-screen 4xMSAA by default and additional render target validations.

Author: chinmaygarde

impeller/aiks/aiks_unittests.cc

@@ -127,6 +127,17 @@ TEST_F(AiksTest, CanRenderGroupOpacity) {
 
   canvas.Restore();
 
+  // ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
+}
+
+TEST_F(AiksTest, CanPerformFullScreenMSAA) {
+  Canvas canvas;
+
+  Paint red;
+  red.color = Color::Red();
+
+  canvas.DrawCircle({250, 250}, 125, red);
+
   ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
 }
 

impeller/aiks/canvas.cc

@@ -91,6 +91,15 @@ void Canvas::DrawPath(Path path, Paint paint) {
   GetCurrentPass().AddEntity(std::move(entity));
 }
 
+void Canvas::DrawRect(Rect rect, Paint paint) {
+  DrawPath(PathBuilder{}.AddRect(rect).CreatePath(), std::move(paint));
+}
+
+void Canvas::DrawCircle(Point center, Scalar radius, Paint paint) {
+  DrawPath(PathBuilder{}.AddCircle(center, radius).CreatePath(),
+           std::move(paint));
+}
+
 void Canvas::SaveLayer(Paint paint, std::optional<Rect> bounds) {
   GetCurrentPass().SetDelegate(
       std::make_unique<PaintPassDelegate>(std::move(paint)));
@@ -189,10 +198,6 @@ size_t Canvas::GetStencilDepth() const {
   return xformation_stack_.back().stencil_depth;
 }
 
-void Canvas::DrawRect(Rect rect, Paint paint) {
-  DrawPath(PathBuilder{}.AddRect(rect).CreatePath(), std::move(paint));
-}
-
 void Canvas::Save(bool create_subpass) {
   auto entry = CanvasStackEntry{};
   if (create_subpass) {

impeller/aiks/canvas.h

@@ -53,6 +53,8 @@ class Canvas {
 
   void DrawRect(Rect rect, Paint paint);
 
+  void DrawCircle(Point center, Scalar radius, Paint paint);
+
   void DrawImage(std::shared_ptr<Image> image, Point offset, Paint paint);
 
   void DrawImageRect(std::shared_ptr<Image> image,

impeller/base/BUILD.gn

@@ -12,6 +12,8 @@ impeller_component("base") {
     "config.h",
     "strings.cc",
     "strings.h",
+    "validation.cc",
+    "validation.h",
   ]
 }
 

impeller/base/base.h

@@ -5,3 +5,4 @@
 #pragma once
 
 #include "impeller/base/strings.h"
+#include "impeller/base/validation.h"

impeller/base/validation.cc

@@ -0,0 +1,28 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/impeller/base/validation.h"
+
+#include "flutter/fml/logging.h"
+
+namespace impeller {
+
+ValidationLog::ValidationLog() = default;
+
+ValidationLog::~ValidationLog() {
+  FML_LOG(ERROR) << stream_.str();
+  ImpellerValidationBreak();
+}
+
+std::ostream& ValidationLog::GetStream() {
+  return stream_;
+}
+
+void ImpellerValidationBreak() {
+  // Nothing to do. Exists for the debugger.
+  FML_LOG(ERROR) << "Break on " << __FUNCTION__
+                 << " to inspect point of failure.";
+}
+
+}  // namespace impeller

impeller/base/validation.h

@@ -0,0 +1,31 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <sstream>
+
+#include "flutter/fml/macros.h"
+
+namespace impeller {
+
+class ValidationLog {
+ public:
+  ValidationLog();
+
+  ~ValidationLog();
+
+  std::ostream& GetStream();
+
+ private:
+  std::ostringstream stream_;
+
+  FML_DISALLOW_COPY_ASSIGN_AND_MOVE(ValidationLog);
+};
+
+void ImpellerValidationBreak();
+
+}  // namespace impeller
+
+#define VALIDATION_LOG ::impeller::ValidationLog{}.GetStream()

impeller/playground/playground.mm

@@ -144,23 +144,44 @@ static void PlaygroundKeyCallback(GLFWwindow* window,
       return false;
     }
 
-    TextureDescriptor color0_tex;
-    color0_tex.format = PixelFormat::kB8G8R8A8UNormInt;
-    color0_tex.size = {
+    TextureDescriptor msaa_tex_desc;
+    msaa_tex_desc.type = TextureType::k2DMultisample;
+    msaa_tex_desc.sample_count = SampleCount::kCount4;
+    msaa_tex_desc.format = PixelFormat::kB8G8R8A8UNormInt;
+    msaa_tex_desc.size = {
         static_cast<ISize::Type>(current_drawable.texture.width),
         static_cast<ISize::Type>(current_drawable.texture.height)};
-    color0_tex.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
+    msaa_tex_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
+
+    auto msaa_tex =
+        renderer_.GetContext()->GetPermanentsAllocator()->CreateTexture(
+            StorageMode::kDeviceTransient, msaa_tex_desc);
+    if (!msaa_tex) {
+      FML_LOG(ERROR) << "Could not allocate MSAA resolve texture.";
+      return false;
+    }
+
+    msaa_tex->SetLabel("PlaygroundMainColor4xMSAA");
+
+    TextureDescriptor onscreen_tex_desc;
+    onscreen_tex_desc.format = PixelFormat::kB8G8R8A8UNormInt;
+    onscreen_tex_desc.size = msaa_tex_desc.size;
+    onscreen_tex_desc.usage =
+        static_cast<uint64_t>(TextureUsage::kRenderTarget);
 
     ColorAttachment color0;
-    color0.texture =
-        std::make_shared<TextureMTL>(color0_tex, current_drawable.texture);
+    color0.texture = msaa_tex;
     color0.clear_color = Color::DarkSlateGray();
     color0.load_action = LoadAction::kClear;
-    color0.store_action = StoreAction::kStore;
+    color0.store_action = StoreAction::kMultisampleResolve;
+    color0.resolve_texture = std::make_shared<TextureMTL>(
+        onscreen_tex_desc, current_drawable.texture);
 
     TextureDescriptor stencil0_tex;
+    stencil0_tex.type = TextureType::k2DMultisample;
+    stencil0_tex.sample_count = SampleCount::kCount4;
     stencil0_tex.format = PixelFormat::kD32FloatS8UNormInt;
-    stencil0_tex.size = color0_tex.size;
+    stencil0_tex.size = msaa_tex_desc.size;
     stencil0_tex.usage =
         static_cast<TextureUsageMask>(TextureUsage::kRenderTarget);
     auto stencil_texture =

impeller/renderer/backend/metal/allocator_mtl.mm

@@ -111,6 +111,12 @@ static MTLStorageMode ToMTLStorageMode(StorageMode mode) {
   }
 
   auto mtl_texture_desc = ToMTLTextureDescriptor(desc);
+
+  if (!mtl_texture_desc) {
+    FML_DLOG(ERROR) << "Texture descriptor was invalid.";
+    return nullptr;
+  }
+
   mtl_texture_desc.storageMode = ToMTLStorageMode(mode);
   auto texture = [device_ newTextureWithDescriptor:mtl_texture_desc];
   if (!texture) {

impeller/renderer/backend/metal/formats_mtl.h

@@ -206,6 +206,8 @@ constexpr MTLStoreAction ToMTLStoreAction(StoreAction action) {
       return MTLStoreActionDontCare;
     case StoreAction::kStore:
       return MTLStoreActionStore;
+    case StoreAction::kMultisampleResolve:
+      return MTLStoreActionMultisampleResolve;
   }
   return MTLStoreActionDontCare;
 }
@@ -216,6 +218,8 @@ constexpr StoreAction FromMTLStoreAction(MTLStoreAction action) {
       return StoreAction::kDontCare;
     case MTLStoreActionStore:
       return StoreAction::kStore;
+    case MTLStoreActionMultisampleResolve:
+      return StoreAction::kMultisampleResolve;
     default:
       break;
   }
@@ -249,6 +253,16 @@ constexpr MTLClearColor ToMTLClearColor(const Color& color) {
   return MTLClearColorMake(color.red, color.green, color.blue, color.alpha);
 }
 
+constexpr MTLTextureType ToMTLTextureType(TextureType type) {
+  switch (type) {
+    case TextureType::k2D:
+      return MTLTextureType2D;
+    case TextureType::k2DMultisample:
+      return MTLTextureType2DMultisample;
+  }
+  return MTLTextureType2D;
+}
+
 MTLRenderPipelineColorAttachmentDescriptor*
 ToMTLRenderPipelineColorAttachmentDescriptor(
     ColorAttachmentDescriptor descriptor);