Segfaults with Minimal Resize Example

[jwinarske]

I'm trying to understand the interaction required for resizing. This is modified example from other discussion that runs on Wayland, and compiles against the system SDL2. What am I missing on the resize? Something is missing. Also it takes a good 30 second for the window to show up, while the console is spammed with warning messages. This is a debug build.

#include <fstream>
#include <iostream>

#include <filamat/MaterialBuilder.h>
#include <filament/Camera.h>
#include <filament/Engine.h>
#include <filament/IndexBuffer.h>
#include <filament/LightManager.h>
#include <filament/RenderableManager.h>
#include <filament/Renderer.h>
#include <filament/Scene.h>
#include <filament/Skybox.h>
#include <filament/View.h>
#include <filament/Viewport.h>

#include <utils/EntityManager.h>

#include <math/norm.h>

#include <gltfio/AssetLoader.h>
#include <gltfio/ResourceLoader.h>

#include <SDL2/SDL.h>
#include <SDL2/SDL_syswm.h>
#include <SDL2/SDL_video.h>

static struct {
  struct wl_display* display;
  struct wl_surface* surface;
  uint32_t width;
  uint32_t height;
} native_window;

volatile uint32_t gWidth, gHeight;

static int OnResize(void* data, SDL_Event* event) {
  if (event->type == SDL_WINDOWEVENT &&
      event->window.event == SDL_WINDOWEVENT_RESIZED) {
    SDL_Window* win = SDL_GetWindowFromID(event->window.windowID);
    if (win == (SDL_Window*)data) {
      SDL_GetWindowSizeInPixels(win, (int*)&gWidth, (int*)&gHeight);
    }
  }
  return 0;
}

void* getNativeWindow(SDL_Window* sdlWindow) {
  SDL_SysWMinfo wmi;
  SDL_VERSION(&wmi.version);
  SDL_GetWindowWMInfo(sdlWindow, &wmi);
  if (wmi.subsystem == SDL_SYSWM_X11) {
    auto win = (Window)wmi.info.x11.window;
    return (void*)win;
  } else if (wmi.subsystem == SDL_SYSWM_WAYLAND) {
    // The default Wayland swap chain extent is {0,0}
    // hence having to set the size
    SDL_GetWindowSizeInPixels(sdlWindow, (int*)&gWidth, (int*)&gHeight);
    // requires static
    native_window = {wmi.info.wl.display, wmi.info.wl.surface, gWidth, gHeight};
    return (void*)&native_window;
  } else {
    std::cout << "Unknown SDL subsystem";
    return nullptr;
  }
}

SDL_Window* createWindow() {
  const uint32_t windowFlags = SDL_WINDOW_VULKAN | SDL_WINDOW_SHOWN |
                               SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
  SDL_Window* win =
      SDL_CreateWindow("Hello Filament!", 100, 100, 600, 400, windowFlags);
  if (win == nullptr) {
    std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
    SDL_Quit();
    return nullptr;
  }
  SDL_AddEventWatch(OnResize, win);

  return win;
}

int main() {
  SDL_Init(SDL_INIT_VIDEO);

  using namespace filament;
  using namespace math;
  using namespace utils;

  static constexpr uint32_t indices[] = {0, 1, 2, 2, 3, 0};

  static constexpr math::float3 vertices[] = {
      {-10, 0, -10},
      {-10, 0, 10},
      {10, 0, 10},
      {10, 0, -10},
  };

  short4 tbn = math::packSnorm16(
      mat3f::packTangentFrame(math::mat3f{float3{1.0f, 0.0f, 0.0f},
                                          float3{0.0f, 0.0f, 1.0f},
                                          float3{0.0f, 1.0f, 0.0f}})
          .xyzw);

  const static math::short4 normals[]{tbn, tbn, tbn, tbn};
  SDL_Window* window = createWindow();

  Engine* engine = Engine::create(filament::backend::Backend::VULKAN);
  SwapChain* swapChain = engine->createSwapChain(getNativeWindow(window));
  Renderer* renderer = engine->createRenderer();

  auto cameraEntity = EntityManager::get().create();
  Camera* camera = engine->createCamera(cameraEntity);
  camera->lookAt(float3(0, 50.5f, 0), float3(0, 0, 0), float3(1.f, 0, 0));
  camera->setProjection(45.0, double(gWidth) / gHeight, 0.1, 50,
                        Camera::Fov::VERTICAL);

  Scene* scene = engine->createScene();

  View* view = engine->createView();
  view->setCamera(camera);
  view->setViewport({0, 0, gWidth, gHeight});
  view->setScene(scene);

  VertexBuffer* vertexBuffer =
      VertexBuffer::Builder()
          .vertexCount(4)
          .bufferCount(2)
          .attribute(VertexAttribute::POSITION, 0,
                     VertexBuffer::AttributeType::FLOAT3)
          .attribute(VertexAttribute::TANGENTS, 1,
                     VertexBuffer::AttributeType::SHORT4)
          .normalized(VertexAttribute::TANGENTS)
          .build(*engine);

  vertexBuffer->setBufferAt(
      *engine, 0,
      VertexBuffer::BufferDescriptor(
          vertices, vertexBuffer->getVertexCount() * sizeof(vertices[0])));
  vertexBuffer->setBufferAt(
      *engine, 1,
      VertexBuffer::BufferDescriptor(
          normals, vertexBuffer->getVertexCount() * sizeof(normals[0])));

  IndexBuffer* indexBuffer =
      IndexBuffer::Builder().indexCount(6).build(*engine);

  indexBuffer->setBuffer(
      *engine, IndexBuffer::BufferDescriptor(
                   indices, indexBuffer->getIndexCount() * sizeof(uint32_t)));

  auto skybox = Skybox::Builder().color({0.5, 0.5, 0.5, 1.0}).build(*engine);
  scene->setSkybox(skybox);

  filamat::MaterialBuilder::init();
  filamat::MaterialBuilder builder;
  builder.name("Some material")
      .material(
          "    void material(inout MaterialInputs material) {\n"
          "        prepareMaterial(material);\n"
          "        material.baseColor.rgb = materialParams.baseColor;\n"
          "        material.metallic = materialParams.metallic;\n"
          "        material.roughness = materialParams.roughness;\n"
          "        material.reflectance = materialParams.reflectance;\n"
          "    }")
      .parameter("baseColor", filament::backend::UniformType::FLOAT3)
      .parameter("metallic", filament::backend::UniformType::FLOAT)
      .parameter("roughness", filament::backend::UniformType::FLOAT)
      .parameter("reflectance", filament::backend::UniformType::FLOAT)
      .shading(filamat::MaterialBuilder::Shading::LIT)
      .targetApi(filamat::MaterialBuilder::TargetApi::ALL)
      .platform(filamat::MaterialBuilder::Platform::ALL);

  filamat::Package package = builder.build(engine->getJobSystem());

  Material* material = Material::Builder()
                           .package(package.getData(), package.getSize())
                           .build(*engine);
  material->setDefaultParameter("baseColor", RgbType::LINEAR, float3{0, 1, 0});
  material->setDefaultParameter("metallic", 0.0f);
  material->setDefaultParameter("roughness", 0.4f);
  material->setDefaultParameter("reflectance", 0.5f);

  MaterialInstance* materialInstance = material->createInstance();

  Entity renderable = EntityManager::get().create();

  Entity light = EntityManager::get().create();

  LightManager::Builder(LightManager::Type::SUN)
      .color(Color::toLinear<ACCURATE>(sRGBColor(0.98f, 0.92f, 0.89f)))
      .intensity(110000)
      .direction({0.7, -1, -0.8})
      .sunAngularRadius(1.9f)
      .castShadows(true)
      .build(*engine, light);

  scene->addEntity(light);

  // build a quad
  RenderableManager::Builder(1)
      .boundingBox({{-1, -1, -1}, {1, 1, 1}})
      .material(0, materialInstance)
      .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, vertexBuffer,
                indexBuffer, 0, 6)
      .culling(false)
      .build(*engine, renderable);
  scene->addEntity(renderable);

  volatile uint32_t prev_width = gWidth;
  volatile uint32_t prev_height = gHeight;
  bool keep_window_open = true;
  while (keep_window_open) {
    SDL_Event e;
    while (SDL_PollEvent(&e) > 0) {
      switch (e.type) {
        case SDL_QUIT:
          keep_window_open = false;
          break;
      }

      if (prev_width != gWidth || prev_height != gHeight) {
        prev_width = gWidth;
        prev_height = gHeight;
        engine->destroy(swapChain);
        swapChain = engine->createSwapChain(getNativeWindow(window));
        view->setViewport({0, 0, gWidth, gHeight});
        camera->setProjection(45.0, double(gWidth) / gHeight, 0.1, 50,
                              Camera::Fov::VERTICAL);
      }

      // beginFrame() returns false if we need to skip a frame
      if (renderer->beginFrame(swapChain)) {
        // for each View
        renderer->render(view);
        renderer->endFrame();
      }
      SDL_UpdateWindowSurface(window);
      SDL_Delay(16);
    }
  }

  engine->destroy(scene);
  engine->destroy(view);
  engine->destroy(cameraEntity);
  engine->destroy(light);
  engine->destroy(skybox);
  engine->destroy(renderable);
  engine->destroy(indexBuffer);
  engine->destroy(vertexBuffer);
  engine->destroy(materialInstance);
  engine->destroy(material);
  engine->destroy(renderer);
  engine->destroy(swapChain);
  Engine::destroy(engine);

  SDL_Quit();
  return 0;
}

[jwinarske]

Upon multiple max/restore sequences, it ends up in a segfault. Some stack examples:

[libc.so.6] __pthread_kill_implementation 0x00007ffff7d10884
[libc.so.6] raise 0x00007ffff7cbfafe
[libc.so.6] abort 0x00007ffff7ca887f
[simple] utils::abort debug.cpp:30
[simple] utils::panic debug.cpp:35
[simple] filament::backend::VulkanCommands::flush VulkanCommands.cpp:310
[simple] filament::backend::VulkanSwapChain::present VulkanSwapChain.cpp:101
[simple] filament::backend::VulkanDriver::commit VulkanDriver.cpp:1360
[simple] filament::backend::invoke<…> CommandStream.h:92
[simple] filament::backend::trampoline<…> CommandStream.h:97
[simple] filament::backend::apply<…> CommandStream.h:102
[simple] filament::backend::CommandType<void (filament::backend::Driver::*)(filament::backend::Handle<filament::backend::HwSwapChain>)>::Command<&filament::backend::Driver::commit>::execute<void (filament::backend::VulkanDriver::*)(filament::backend::Handle<filament::backend::HwSwapChain>), filament::backend::VulkanDriver&> CommandStream.h:142
[simple] filament::backend::ConcreteDispatcher::commit DriverAPI.inc:405
[simple] filament::backend::CommandBase::execute CommandStream.h:76
[simple] $_0::operator() const CommandStream.cpp:94
[simple] std::__invoke[abi:v160006]<…> invoke.h:394
[simple] std::__invoke_void_return_wrapper::__call<…> invoke.h:487
[simple] std::__function::__alloc_func::operator()[abi:v160006] function.h:185
[simple] std::__function::__func::operator() function.h:356
[simple] std::__function::__value_func::operator()[abi:v160006] const function.h:510
[simple] std::function::operator() const function.h:1156
[simple] filament::backend::Driver::execute Driver.cpp:205
[simple] filament::backend::CommandStream::execute CommandStream.cpp:90
[simple] filament::FEngine::execute Engine.cpp:1162
[simple] filament::FEngine::loop Engine.cpp:660
[simple] std::__1::__invoke[abi:v160006]<int (filament::FEngine::*)(), filament::FEngine*, , void>(int (filament::FEngine::*&&)(), filament::FEngine*&&) invoke.h:359
[simple] std::__thread_execute[abi:v160006]<…> thread:282
[simple] std::__thread_proxy[abi:v160006]<…> thread:293
[libc.so.6] start_thread 0x00007ffff7d0e947
[libc.so.6] clone3 0x00007ffff7d94860

[libvulkan_radeon.so] radv_amdgpu_winsys_cs_submit_internal.constprop 0x00007fffebf69f98
[libvulkan_radeon.so] radv_amdgpu_winsys_cs_submit 0x00007fffebf6ae4c
[libvulkan_radeon.so] radv_queue_submit 0x00007fffebf2c0c3
[libvulkan_radeon.so] vk_queue_submit_final 0x00007fffebfa4876
[libvulkan_radeon.so] vk_queue_submit 0x00007fffebfa534d
[libvulkan_radeon.so] vk_common_QueueSubmit2KHR 0x00007fffebfa5bdb
[libvulkan_radeon.so] vk_common_QueueSubmit 0x00007fffebfad351
[simple] filament::backend::VulkanCommands::flush VulkanCommands.cpp:301
[simple] filament::backend::VulkanSwapChain::present VulkanSwapChain.cpp:101
[simple] filament::backend::VulkanDriver::commit VulkanDriver.cpp:1360
[simple] filament::backend::invoke<…> CommandStream.h:92
[simple] filament::backend::trampoline<…> CommandStream.h:97
[simple] filament::backend::apply<…> CommandStream.h:102
[simple] filament::backend::CommandType<void (filament::backend::Driver::*)(filament::backend::Handle<filament::backend::HwSwapChain>)>::Command<&filament::backend::Driver::commit>::execute<void (filament::backend::VulkanDriver::*)(filament::backend::Handle<filament::backend::HwSwapChain>), filament::backend::VulkanDriver&> CommandStream.h:142
[simple] filament::backend::ConcreteDispatcher::commit DriverAPI.inc:405
[simple] filament::backend::CommandBase::execute CommandStream.h:76
[simple] $_0::operator() const CommandStream.cpp:94
[simple] std::__invoke[abi:v160006]<…> invoke.h:394
[simple] std::__invoke_void_return_wrapper::__call<…> invoke.h:487
[simple] std::__function::__alloc_func::operator()[abi:v160006] function.h:185
[simple] std::__function::__func::operator() function.h:356
[simple] std::__function::__value_func::operator()[abi:v160006] const function.h:510
[simple] std::function::operator() const function.h:1156
[simple] filament::backend::Driver::execute Driver.cpp:205
[simple] filament::backend::CommandStream::execute CommandStream.cpp:90
[simple] filament::FEngine::execute Engine.cpp:1162
[simple] filament::FEngine::loop Engine.cpp:660
[simple] std::__1::__invoke[abi:v160006]<int (filament::FEngine::*)(), filament::FEngine*, , void>(int (filament::FEngine::*&&)(), filament::FEngine*&&) invoke.h:359
[simple] std::__thread_execute[abi:v160006]<…> thread:282
[simple] std::__thread_proxy[abi:v160006]<…> thread:293
[libc.so.6] start_thread 0x00007ffff7d0e947
[libc.so.6] clone3 0x00007ffff7d94860

I haven't tried this on a release build yet, as this would avoid the debug asserts.