Deck size propagation tuneups (#156)

Author: Ilija Puaca

cpp/modules/deck.gl/core/src/lib/deck.cc

@@ -74,8 +74,7 @@ void Deck::draw(wgpu::TextureView textureView, probegl::Error& error,
   probegl::catchError([&]() { this->draw(textureView, onAfterRender); }, error);
 }
 
-Deck::Deck(std::shared_ptr<Deck::Props> props)
-    : Component(props), width{props->width}, height{props->height}, _needsRedraw{"Initial render"} {
+Deck::Deck(std::shared_ptr<Deck::Props> props) : Component(props), _needsRedraw{"Initial render"} {
   this->animationLoop = lumagl::AnimationLoopFactory::createAnimationLoop(props->drawingOptions);
   this->context = std::make_shared<LayerContext>(this, this->animationLoop->device());
   this->layerManager = std::make_shared<LayerManager>(this->context);
@@ -92,6 +91,8 @@ Deck::Deck(std::shared_ptr<Deck::Props> props)
 Deck::~Deck() { this->animationLoop->stop(); }
 
 void Deck::setProps(std::shared_ptr<Deck::Props> props) {
+  this->_setSize({props->width, props->height});
+
   // ViewState tracking
   if (props->initialViewState) {
     if (!props->initialViewState->equals(this->initialViewState)) {
@@ -114,11 +115,8 @@ void Deck::setProps(std::shared_ptr<Deck::Props> props) {
   }
 
   // Update viewManager
-  this->viewManager->setWidth(props->width);
-  this->viewManager->setHeight(props->height);
   this->viewManager->setViews(props->views);
   this->viewManager->setViewState(this->viewState);
-  this->animationLoop->setSize({props->width, props->height});
 }
 
 void Deck::run(std::function<void(Deck*)> onAfterRender) {
@@ -160,6 +158,17 @@ auto Deck::_getViewState() -> std::shared_ptr<ViewState> {
   return this->viewState;
 }
 
+void Deck::_setSize(const lumagl::Size& size) {
+  if (this->_size == size) {
+    return;
+  }
+
+  this->viewManager->setSize(size.width, size.height);
+  this->animationLoop->setSize(size);
+
+  this->_size = size;
+}
+
 void Deck::_redraw(wgpu::RenderPassEncoder pass, std::function<void(Deck*)> onAfterRender, bool force) {
   // If force is falsy, check if we need to redraw
   std::optional<std::string> redrawReason = force ? "Redraw Forced" : this->needsRedraw(true);

cpp/modules/deck.gl/core/src/lib/deck.h

@@ -59,9 +59,6 @@ class Deck : public Component {
   auto props() { return std::dynamic_pointer_cast<Props>(this->_props); }
   void setProps(std::shared_ptr<Deck::Props> props);
 
-  int width{100};   // Dummy value, ensure something is visible if user forgets to set window size
-  int height{100};  // Dummy value, ensure something is visible if user forgets to set window size
-
   void run(std::function<void(Deck*)> onAfterRender = [](Deck*) {});
   void draw(
       wgpu::TextureView textureView, std::function<void(Deck*)> onAfterRender = [](Deck*) {});
@@ -74,6 +71,8 @@ class Deck : public Component {
 
   auto getViews() -> std::list<std::shared_ptr<View>> { return this->viewManager->getViews(); }
 
+  auto size() -> lumagl::Size { return this->_size; };
+
   std::shared_ptr<lumagl::AnimationLoop> animationLoop;
   std::shared_ptr<ViewManager> viewManager{new ViewManager()};
   std::shared_ptr<LayerContext> context;
@@ -85,13 +84,15 @@ class Deck : public Component {
   /// \brief Get the most relevant view state: props.viewState, if supplied, shadows internal viewState.
   auto _getViewState() -> std::shared_ptr<ViewState>;
 
-  auto _createAnimationLoop(const std::shared_ptr<Deck::Props>& props) -> std::shared_ptr<lumagl::AnimationLoop>;
+  void _setSize(const lumagl::Size& size);
+
   void _redraw(wgpu::RenderPassEncoder pass, std::function<void(Deck*)> onAfterRender, bool force = false);
   void _drawLayers(wgpu::RenderPassEncoder pass, std::function<void(Deck*)> onAfterRender,
                    const std::string& redrawReason);
 
   std::optional<std::string> _needsRedraw;
   wgpu::Buffer _viewportUniformsBuffer;
+  lumagl::Size _size;
 };
 
 class Deck::Props : public Component::Props {

cpp/modules/luma.gl/CMakeLists.txt

@@ -77,6 +77,7 @@ set(CORE_SOURCE_FILE_LIST
     core/src/animation-loop.cc
     core/src/model.cc
     core/src/blit-model.cc
+    core/src/size.cc
     )
 set(CORE_TESTS_SOURCE_FILE_LIST
     )

cpp/modules/luma.gl/core/src/animation-loop.cc

@@ -85,7 +85,7 @@ void AnimationLoop::run(std::function<void(wgpu::RenderPassEncoder)> onRender) {
 void AnimationLoop::stop() { this->running = false; }
 
 void AnimationLoop::setSize(const Size& size) {
-  bool sizeChanged = size.width != this->_size.width || size.height != this->_size.height;
+  bool sizeChanged = size != this->_size;
   if (sizeChanged) {
     this->_size = size;
     // TODO(ilija@unfolded.ai): Trigger redraw

cpp/modules/luma.gl/core/src/glfw-animation-loop.cc

@@ -93,9 +93,11 @@ auto GLFWAnimationLoop::devicePixelRatio() -> float {
 }
 
 void GLFWAnimationLoop::setSize(const Size& size) {
-  bool sizeChanged = size.width != this->_size.width || size.height != this->_size.height;
+  bool sizeChanged = size != this->_size;
   if (sizeChanged) {
-    this->_swapchain = this->_createSwapchain(this->_device);
+    glfwSetWindowSize(this->_window, size.width, size.height);
+    this->_swapchain.Configure(this->getPreferredSwapChainTextureFormat(), wgpu::TextureUsage::OutputAttachment,
+                               size.width, size.height);
   }
 
   super::setSize(size);
@@ -160,10 +162,6 @@ auto GLFWAnimationLoop::_initializeGLFW(const wgpu::BackendType backendType, con
   if (!window) {
     throw std::runtime_error("Failed to create GLFW window");
   }
-  // TODO(ilija@unfolded.ai): Handle window resizing
-  //  glfwSetFramebufferSizeCallback(window, [this](GLFWwindow* window, int width, int height) {
-  //    this->setSize(width, height);
-  //  });
 
   return window;
 }

cpp/modules/luma.gl/core/src/metal-animation-loop.mm

@@ -67,10 +67,10 @@
 }
 
 void MetalAnimationLoop::setSize(const Size& size) {
-  bool sizeChanged = size.width != this->_size.width || size.height != this->_size.height;
+  bool sizeChanged = size != this->_size;
   if (sizeChanged) {
-    // TODO(ilija@unfolded.ai): Should we be trying to resize users views/layers?
-    //    this->_swapchain = this->_createSwapchain(this->_device);
+    this->_swapchain.Configure(this->getPreferredSwapChainTextureFormat(), wgpu::TextureUsage::OutputAttachment,
+                               size.width, size.height);
   }
 
   super::setSize(size);

cpp/modules/luma.gl/core/src/size.cc

@@ -0,0 +1,27 @@
+// Copyright (c) 2020 Unfolded Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#include "./size.h"  // NOLINT(build/include)
+
+using namespace lumagl;
+
+auto operator==(const Size& s1, const Size& s2) -> bool { return s1.width == s2.width && s1.height == s2.height; }
+
+auto operator!=(const Size& s1, const Size& s2) -> bool { return !(s1 == s2); }

cpp/modules/luma.gl/core/src/size.h

@@ -25,11 +25,12 @@ namespace lumagl {
 
 struct Size {
  public:
+  Size() : width{0}, height{0} {}
   Size(int width, int height) : width{width}, height{height} {}
 
   template <typename T>
   auto operator*(const T& value) -> Size {
-    return Size{this->width * static_cast<int>(value), this->height * static_cast<int>(value)};
+    return Size{static_cast<int>(this->width * value), static_cast<int>(this->height * value)};
   }
 
   int width;
@@ -38,4 +39,7 @@ struct Size {
 
 }  // namespace lumagl
 
+auto operator==(const lumagl::Size& s1, const lumagl::Size& s2) -> bool;
+auto operator!=(const lumagl::Size& s1, const lumagl::Size& s2) -> bool;
+
 #endif  // LUMAGL_CORE_SIZE_H

cpp/modules/luma.gl/webgpu/src/backends/glfw/metal-binding.mm

@@ -66,14 +66,18 @@ DawnSwapChainError Configure(WGPUTextureFormat format, WGPUTextureUsage usage, u
     ASSERT(height > 0);
 
     NSView* contentView = [mNsWindow contentView];
-    [contentView setWantsLayer:YES];
-
     // Make sure display scale factor is taken into account
     CGSize drawableSize = CGSizeMake(width * mNsWindow.backingScaleFactor, height * mNsWindow.backingScaleFactor);
 
-    mLayer = [CAMetalLayer layer];
-    [mLayer setDevice:mMtlDevice];
-    [mLayer setPixelFormat:MTLPixelFormatBGRA8Unorm];
+    // If swapchain was not configured previously, create a new layer and set it up
+    if (!mLayer) {
+      [contentView setWantsLayer:YES];
+
+      mLayer = [CAMetalLayer layer];
+      [mLayer setDevice:mMtlDevice];
+      [mLayer setPixelFormat:MTLPixelFormatBGRA8Unorm];
+    }
+
     [mLayer setDrawableSize:drawableSize];
 
     constexpr uint32_t kFramebufferOnlyTextureUsages = WGPUTextureUsage_OutputAttachment | WGPUTextureUsage_Present;

cpp/modules/luma.gl/webgpu/src/backends/metal-binding.mm

@@ -60,8 +60,11 @@ DawnSwapChainError Configure(WGPUTextureFormat format, WGPUTextureUsage usage, u
     // Make sure UI methods are called on the main thread
     // No retain cycle here as there is no reference counting in C++
     executeOnMainThread(^{
-      this->_view.device = mMtlDevice;
-      this->mLayer = (CAMetalLayer*)this->_view.layer;
+      // If swapchain was not configured previously, create a new layer and set it up
+      if (!this->mLayer) {
+        this->_view.device = mMtlDevice;
+        this->mLayer = (CAMetalLayer*)this->_view.layer;
+      }
 
       constexpr uint32_t kFramebufferOnlyTextureUsages = WGPUTextureUsage_OutputAttachment | WGPUTextureUsage_Present;
       bool hasOnlyFramebufferUsages = !(usage & (~kFramebufferOnlyTextureUsages));