not even at swapchain

main.dart

// @dart = 2.8

import 'package:glfw/glfw.dart';
import 'package:vulkan/vulkan.dart';
import 'dart:ffi';
import 'package:ffi/ffi.dart';

void main() {
  // Init dart specific FFI libraries.
  initGlfw();
  initVulkan();

  // Init GLFW window.
  glfwInit();
  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
  glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

  var name = "Slim~Shady".toNativeUtf8();
  var window = glfwCreateWindow(800, 600, name, nullptr, nullptr);
  var appInfo = createInstance();

  var glfwExtensionCount = calloc<Uint32>();
  var glfwExtensions = glfwGetRequiredInstanceExtensions(glfwExtensionCount);
  var createInfo = calloc<VkInstanceCreateInfo>()
    ..ref.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
    ..ref.pApplicationInfo = appInfo
    ..ref.enabledExtensionCount = glfwExtensionCount.value
    ..ref.ppEnabledExtensionNames = glfwExtensions
    ..ref.enabledLayerCount = 0;

  var instance = calloc<Pointer<VkInstance>>();
  if (vkCreateInstance(createInfo, nullptr, instance) != VK_SUCCESS) {
    return;
  }
  // create window handle.
  var surface = calloc<Pointer<VkSurfaceKHR>>();
  if (glfwCreateWindowSurface(instance.value, window, nullptr, surface) != VK_SUCCESS) {
    print('failed to create surface');
    return;
  }

  /// Select the physical device (TODO).
  var deviceCount = calloc<Uint32>();
  vkEnumeratePhysicalDevices(instance.value, deviceCount, nullptr);
  var devices = calloc<Pointer<VkPhysicalDevice>>(sizeOf<Pointer<VkPhysicalDevice>>() * deviceCount.value);
  vkEnumeratePhysicalDevices(instance.value, deviceCount, devices);
  Pointer<VkPhysicalDevice> physicalDevice;

  for (var i = 0; i < deviceCount.value; i++) {
    physicalDevice = devices.elementAt(i).value;
    if (isDeviceSuitable(physicalDevice, surface.value)) {
      break;
    }
  }

  // Create the queue info.
  var indices = findQueueFamilies(physicalDevice, surface.value);
  var queueCreateInfos = <Pointer<VkDeviceQueueCreateInfo>>[];
  var uniqueQueueFamilies = <int>{indices.graphicsFamily, indices.presentFamily};
  var queuePriority = calloc<Float>()
    ..value = 1.0;

  for (var queueFamily in uniqueQueueFamilies) {
    var queueCreateInfo = calloc<VkDeviceQueueCreateInfo>()
      ..ref.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
      ..ref.queueFamilyIndex = queueFamily
      ..ref.queueCount = 1
      ..ref.pQueuePriorities = queuePriority;
    queueCreateInfos.add(queueCreateInfo);
  }

  var queueCreateInfosArray = calloc<Pointer<VkDeviceQueueCreateInfo>>(sizeOf<VkDeviceQueueCreateInfo>() * uniqueQueueFamilies.length);
  for (var i = 0; i < uniqueQueueFamilies.length; i++) {
    queueCreateInfosArray[i] = queueCreateInfos[i];
  }

  var queueCreateInfo = calloc<VkDeviceQueueCreateInfo>();
  queueCreateInfo
    ..ref.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
    ..ref.queueFamilyIndex = indices.graphicsFamily
    ..ref.queueCount = 1
    ..ref.pQueuePriorities = queuePriority;

  // Physical device features.
  var physicalFeatures = calloc<VkPhysicalDeviceFeatures>();

  // Physical device.
  var deviceInfo = calloc<VkDeviceCreateInfo>()
    ..ref.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
    ..ref.pQueueCreateInfos = queueCreateInfo
    ..ref.queueCreateInfoCount = 1
    ..ref.pEnabledFeatures = physicalFeatures
    ..ref.enabledExtensionCount = 0
    ..ref.queueCreateInfoCount = queueCreateInfos.length
    ..ref.pQueueCreateInfos = queueCreateInfosArray.value;

  var device = calloc<Pointer<VkDevice>>();
  if (vkCreateDevice(physicalDevice, deviceInfo, nullptr, device) != VK_SUCCESS) {
    print('failed to create physical device');
    return;
  }

  // Grab handle to queues.
  var graphicsQueue = calloc<Pointer<VkQueue>>();

  vkGetDeviceQueue(device.value, indices.graphicsFamily, 0, graphicsQueue);

  // create present queue.
  var presentQueue = calloc<Pointer<VkQueue>>();
  vkGetDeviceQueue(device.value, indices.presentFamily, 0, presentQueue);

  try {
    while (glfwWindowShouldClose(window) == 0) {
      glfwPollEvents();
    }
  } finally {
    vkDestroySurfaceKHR(instance.value, surface.value, nullptr);
    vkDestroyInstance(instance.value, nullptr);
    glfwDestroyWindow(window);
    glfwTerminate();
  }
}

bool isDeviceSuitable(Pointer<VkPhysicalDevice> device,  Pointer<VkSurfaceKHR> surface) {
  var deviceProperties = calloc<VkPhysicalDeviceProperties>();
  vkGetPhysicalDeviceProperties(device, deviceProperties);
  var queueFamiliesIndicies = findQueueFamilies(device, surface);
  return queueFamiliesIndicies.graphicsFamily != null && queueFamiliesIndicies.presentFamily != null;
}

Pointer<VkApplicationInfo> createInstance() {
  var appInfo = calloc<VkApplicationInfo>();
  appInfo.ref.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
  appInfo.ref.pApplicationName = "Hello Triangle".toNativeUtf8();
  appInfo.ref.applicationVersion = 1;
  appInfo.ref.pEngineName = "No Engine".toNativeUtf8();
  appInfo.ref.engineVersion = 1;
  appInfo.ref.apiVersion = 1;
  return appInfo;
}

class QueueFamilyIndices {
  int graphicsFamily;
  int presentFamily;
}

QueueFamilyIndices findQueueFamilies(Pointer<VkPhysicalDevice> device, Pointer<VkSurfaceKHR> surface) {
  var indices = QueueFamilyIndices();

  var queueFamilyCount = calloc<Uint32>();
  vkGetPhysicalDeviceQueueFamilyProperties(device, queueFamilyCount, nullptr);

  var queueFamilies = calloc<VkQueueFamilyProperties>(sizeOf<VkQueueFamilyProperties>() * queueFamilyCount.value);
  vkGetPhysicalDeviceQueueFamilyProperties(device, queueFamilyCount, queueFamilies);

  for (var i = 0; i < queueFamilyCount.value; i++) {
    var queueFamily = queueFamilies.elementAt(i);
    if ((queueFamily.ref.queueFlags & VK_QUEUE_GRAPHICS_BIT) == 1) {
      indices.graphicsFamily = i;
    }
    var presentSupport = calloc<Pointer<Uint32>>();
    vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, presentSupport);
    print(presentSupport.value);
    if (presentSupport.value == 1) {
      indices.presentFamily = i;
    }
  }

  return indices;
}