8 files changed, 27 insertions, 655 deletions

diff --git a/include/amber/amber_vulkan.h b/include/amber/amber_vulkan.h
index c1b09c0..71aa4eb 100644
--- a/include/amber/amber_vulkan.h
+++ b/include/amber/amber_vulkan.h
@@ -24,9 +24,10 @@
 
 namespace amber {
 
-/// Configuration for the Vulkan Engine.
+/// Configuration for the Vulkan Engine. The following are all required when
+/// when using the vulkan backend.
 struct VulkanEngineConfig : public EngineConfig {
-  /// REQUIRED. The Vulkan instance procedure loader.
+  /// The Vulkan instance procedure loader.
   PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
 
   /// The VkInstance to use.
diff --git a/src/vulkan/CMakeLists.txt b/src/vulkan/CMakeLists.txt
index eed0b19..cc9eb94 100644
--- a/src/vulkan/CMakeLists.txt
+++ b/src/vulkan/CMakeLists.txt
@@ -24,7 +24,6 @@ set(VULKAN_ENGINE_SOURCES
     frame_buffer.cc
     graphics_pipeline.cc
     index_buffer.cc
-    log.cc
     image.cc
     pipeline.cc
     push_constant.cc
diff --git a/src/vulkan/device.cc b/src/vulkan/device.cc
index e0318f1..91e1fd4 100644
--- a/src/vulkan/device.cc
+++ b/src/vulkan/device.cc
@@ -20,234 +20,11 @@
 #include <vector>
 
 #include "src/make_unique.h"
-#include "src/vulkan/log.h"
 
 namespace amber {
 namespace vulkan {
 namespace {
 
-const char* const kRequiredValidationLayers[] = {
-#ifdef __ANDROID__
-    // Note that the order of enabled layers is important. It is
-    // based on Android NDK Vulkan document.
-    "VK_LAYER_GOOGLE_threading",      "VK_LAYER_LUNARG_parameter_validation",
-    "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation",
-    "VK_LAYER_GOOGLE_unique_objects",
-#else   // __ANDROID__
-    "VK_LAYER_LUNARG_standard_validation",
-#endif  // __ANDROID__
-};
-
-const size_t kNumberOfRequiredValidationLayers =
-    sizeof(kRequiredValidationLayers) / sizeof(const char*);
-
-const char* kExtensionForValidationLayer = "VK_EXT_debug_report";
-
-VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugReportFlagsEXT flag,
-                                             VkDebugReportObjectTypeEXT,
-                                             uint64_t,
-                                             size_t,
-                                             int32_t,
-                                             const char* layerPrefix,
-                                             const char* msg,
-                                             void*) {
-  std::string flag_message;
-  switch (flag) {
-    case VK_DEBUG_REPORT_ERROR_BIT_EXT:
-      flag_message = "[ERROR]";
-      break;
-    case VK_DEBUG_REPORT_WARNING_BIT_EXT:
-      flag_message = "[WARNING]";
-      break;
-    default:
-      flag_message = "[UNKNOWN]";
-      break;
-  }
-
-  LogError(flag_message + " validation layer (" + layerPrefix + "):\n" + msg);
-  return VK_FALSE;
-}
-
-VkPhysicalDeviceFeatures RequestedFeatures(
-    const std::vector<Feature>& required_features) {
-  VkPhysicalDeviceFeatures requested_features = VkPhysicalDeviceFeatures();
-  for (const auto& feature : required_features) {
-    switch (feature) {
-      case Feature::kRobustBufferAccess:
-        requested_features.robustBufferAccess = VK_TRUE;
-        break;
-      case Feature::kFullDrawIndexUint32:
-        requested_features.fullDrawIndexUint32 = VK_TRUE;
-        break;
-      case Feature::kImageCubeArray:
-        requested_features.imageCubeArray = VK_TRUE;
-        break;
-      case Feature::kIndependentBlend:
-        requested_features.independentBlend = VK_TRUE;
-        break;
-      case Feature::kGeometryShader:
-        requested_features.geometryShader = VK_TRUE;
-        break;
-      case Feature::kTessellationShader:
-        requested_features.tessellationShader = VK_TRUE;
-        break;
-      case Feature::kSampleRateShading:
-        requested_features.sampleRateShading = VK_TRUE;
-        break;
-      case Feature::kDualSrcBlend:
-        requested_features.dualSrcBlend = VK_TRUE;
-        break;
-      case Feature::kLogicOp:
-        requested_features.logicOp = VK_TRUE;
-        break;
-      case Feature::kMultiDrawIndirect:
-        requested_features.multiDrawIndirect = VK_TRUE;
-        break;
-      case Feature::kDrawIndirectFirstInstance:
-        requested_features.drawIndirectFirstInstance = VK_TRUE;
-        break;
-      case Feature::kDepthClamp:
-        requested_features.depthClamp = VK_TRUE;
-        break;
-      case Feature::kDepthBiasClamp:
-        requested_features.depthBiasClamp = VK_TRUE;
-        break;
-      case Feature::kFillModeNonSolid:
-        requested_features.fillModeNonSolid = VK_TRUE;
-        break;
-      case Feature::kDepthBounds:
-        requested_features.depthBounds = VK_TRUE;
-        break;
-      case Feature::kWideLines:
-        requested_features.wideLines = VK_TRUE;
-        break;
-      case Feature::kLargePoints:
-        requested_features.largePoints = VK_TRUE;
-        break;
-      case Feature::kAlphaToOne:
-        requested_features.alphaToOne = VK_TRUE;
-        break;
-      case Feature::kMultiViewport:
-        requested_features.multiViewport = VK_TRUE;
-        break;
-      case Feature::kSamplerAnisotropy:
-        requested_features.samplerAnisotropy = VK_TRUE;
-        break;
-      case Feature::kTextureCompressionETC2:
-        requested_features.textureCompressionETC2 = VK_TRUE;
-        break;
-      case Feature::kTextureCompressionASTC_LDR:
-        requested_features.textureCompressionASTC_LDR = VK_TRUE;
-        break;
-      case Feature::kTextureCompressionBC:
-        requested_features.textureCompressionBC = VK_TRUE;
-        break;
-      case Feature::kOcclusionQueryPrecise:
-        requested_features.occlusionQueryPrecise = VK_TRUE;
-        break;
-      case Feature::kPipelineStatisticsQuery:
-        requested_features.pipelineStatisticsQuery = VK_TRUE;
-        break;
-      case Feature::kVertexPipelineStoresAndAtomics:
-        requested_features.vertexPipelineStoresAndAtomics = VK_TRUE;
-        break;
-      case Feature::kFragmentStoresAndAtomics:
-        requested_features.fragmentStoresAndAtomics = VK_TRUE;
-        break;
-      case Feature::kShaderTessellationAndGeometryPointSize:
-        requested_features.shaderTessellationAndGeometryPointSize = VK_TRUE;
-        break;
-      case Feature::kShaderImageGatherExtended:
-        requested_features.shaderImageGatherExtended = VK_TRUE;
-        break;
-      case Feature::kShaderStorageImageExtendedFormats:
-        requested_features.shaderStorageImageExtendedFormats = VK_TRUE;
-        break;
-      case Feature::kShaderStorageImageMultisample:
-        requested_features.shaderStorageImageMultisample = VK_TRUE;
-        break;
-      case Feature::kShaderStorageImageReadWithoutFormat:
-        requested_features.shaderStorageImageReadWithoutFormat = VK_TRUE;
-        break;
-      case Feature::kShaderStorageImageWriteWithoutFormat:
-        requested_features.shaderStorageImageWriteWithoutFormat = VK_TRUE;
-        break;
-      case Feature::kShaderUniformBufferArrayDynamicIndexing:
-        requested_features.shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
-        break;
-      case Feature::kShaderSampledImageArrayDynamicIndexing:
-        requested_features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
-        break;
-      case Feature::kShaderStorageBufferArrayDynamicIndexing:
-        requested_features.shaderStorageBufferArrayDynamicIndexing = VK_TRUE;
-        break;
-      case Feature::kShaderStorageImageArrayDynamicIndexing:
-        requested_features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
-        break;
-      case Feature::kShaderClipDistance:
-        requested_features.shaderClipDistance = VK_TRUE;
-        break;
-      case Feature::kShaderCullDistance:
-        requested_features.shaderCullDistance = VK_TRUE;
-        break;
-      case Feature::kShaderFloat64:
-        requested_features.shaderFloat64 = VK_TRUE;
-        break;
-      case Feature::kShaderInt64:
-        requested_features.shaderInt64 = VK_TRUE;
-        break;
-      case Feature::kShaderInt16:
-        requested_features.shaderInt16 = VK_TRUE;
-        break;
-      case Feature::kShaderResourceResidency:
-        requested_features.shaderResourceResidency = VK_TRUE;
-        break;
-      case Feature::kShaderResourceMinLod:
-        requested_features.shaderResourceMinLod = VK_TRUE;
-        break;
-      case Feature::kSparseBinding:
-        requested_features.sparseBinding = VK_TRUE;
-        break;
-      case Feature::kSparseResidencyBuffer:
-        requested_features.sparseResidencyBuffer = VK_TRUE;
-        break;
-      case Feature::kSparseResidencyImage2D:
-        requested_features.sparseResidencyImage2D = VK_TRUE;
-        break;
-      case Feature::kSparseResidencyImage3D:
-        requested_features.sparseResidencyImage3D = VK_TRUE;
-        break;
-      case Feature::kSparseResidency2Samples:
-        requested_features.sparseResidency2Samples = VK_TRUE;
-        break;
-      case Feature::kSparseResidency4Samples:
-        requested_features.sparseResidency4Samples = VK_TRUE;
-        break;
-      case Feature::kSparseResidency8Samples:
-        requested_features.sparseResidency8Samples = VK_TRUE;
-        break;
-      case Feature::kSparseResidency16Samples:
-        requested_features.sparseResidency16Samples = VK_TRUE;
-        break;
-      case Feature::kSparseResidencyAliased:
-        requested_features.sparseResidencyAliased = VK_TRUE;
-        break;
-      case Feature::kVariableMultisampleRate:
-        requested_features.variableMultisampleRate = VK_TRUE;
-        break;
-      case Feature::kInheritedQueries:
-        requested_features.inheritedQueries = VK_TRUE;
-        break;
-      case Feature::kFramebuffer:
-      case Feature::kDepthStencil:
-      case Feature::kFenceTimeout:
-      case Feature::kUnknown:
-        break;
-    }
-  }
-  return requested_features;
-}
-
 bool AreAllRequiredFeaturesSupported(
     const VkPhysicalDeviceFeatures& available_features,
     const std::vector<Feature>& required_features) {
@@ -509,8 +286,6 @@ bool AreAllExtensionsSupported(
 
 }  // namespace
 
-Device::Device() = default;
-
 Device::Device(VkInstance instance,
                VkPhysicalDevice physical_device,
                const VkPhysicalDeviceFeatures& available_features,
@@ -524,96 +299,41 @@ Device::Device(VkInstance instance,
       available_physical_device_extensions_(available_extensions),
       queue_family_index_(queue_family_index),
       device_(device),
-      queue_(queue),
-      destroy_device_(false) {}
+      queue_(queue) {}
 
 Device::~Device() = default;
 
-void Device::Shutdown() {
-  if (destroy_device_) {
-    ptrs_.vkDestroyDevice(device_, nullptr);
-    ptrs_.vkDestroyDebugReportCallbackEXT(instance_, callback_, nullptr);
-    ptrs_.vkDestroyInstance(instance_, nullptr);
-  }
-}
-
-Result Device::LoadVulkanGlobalPointers(
-    PFN_vkGetInstanceProcAddr getInstanceProcAddr) {
-#define AMBER_VK_FUNC(func)
-#define AMBER_VK_GLOBAL_FUNC(func)                             \
-  if (!(ptrs_.func = reinterpret_cast<PFN_##func>(             \
-            getInstanceProcAddr(VK_NULL_HANDLE, #func)))) {    \
-    return Result("Vulkan: Unable to load " #func " pointer"); \
-  }
-#include "src/vulkan/vk-funcs.inc"
-#undef AMBER_VK_GLOBAL_FUNC
-#undef AMBER_VK_FUNC
-
-  return {};
-}
-
 Result Device::LoadVulkanPointers(
     PFN_vkGetInstanceProcAddr getInstanceProcAddr) {
-#define AMBER_VK_GLOBAL_FUNC(func)
 #define AMBER_VK_FUNC(func)                                    \
   if (!(ptrs_.func = reinterpret_cast<PFN_##func>(             \
             getInstanceProcAddr(instance_, #func)))) {         \
     return Result("Vulkan: Unable to load " #func " pointer"); \
   }
-#include "src/vulkan/vk-funcs.inc"  // NOLINT(build/include)
+#include "src/vulkan/vk-funcs.inc"
 #undef AMBER_VK_FUNC
-#undef AMBER_VK_GLOBAL_FUNC
-
   return {};
 }
 
 Result Device::Initialize(PFN_vkGetInstanceProcAddr getInstanceProcAddr,
                           const std::vector<Feature>& required_features,
                           const std::vector<std::string>& required_extensions) {
-  Result r = LoadVulkanGlobalPointers(getInstanceProcAddr);
+  Result r = LoadVulkanPointers(getInstanceProcAddr);
   if (!r.IsSuccess())
     return r;
 
-  if (destroy_device_) {
-    r = CreateInstance();
-    if (!r.IsSuccess())
-      return r;
+  if (!AreAllRequiredFeaturesSupported(available_physical_device_features_,
+                                       required_features)) {
+    return Result(
+        "Vulkan: Device::Initialize given physical device does not support "
+        "required features");
   }
 
-  r = LoadVulkanPointers(getInstanceProcAddr);
-  if (!r.IsSuccess())
-    return r;
-
-  if (destroy_device_) {
-    r = CreateDebugReportCallback();
-    if (!r.IsSuccess())
-      return r;
-
-    r = ChoosePhysicalDevice(required_features, required_extensions);
-    if (!r.IsSuccess())
-      return r;
-
-    r = CreateDevice(required_features, required_extensions);
-    if (!r.IsSuccess())
-      return r;
-
-    ptrs_.vkGetDeviceQueue(device_, queue_family_index_, 0, &queue_);
-    if (queue_ == VK_NULL_HANDLE)
-      return Result("Vulkan::Calling vkGetDeviceQueue Fail");
-  } else {
-    if (!AreAllRequiredFeaturesSupported(available_physical_device_features_,
-                                         required_features)) {
-      return Result(
-          "Vulkan: Device::Initialize given physical device does not support "
-          "required features");
-    }
-
-    if (!AreAllExtensionsSupported(available_physical_device_extensions_,
-                                   required_extensions)) {
-      return Result(
-          "Vulkan: Device::Initialize given physical device does not support "
-          "required extensions");
-    }
+  if (!AreAllExtensionsSupported(available_physical_device_extensions_,
+                                 required_extensions)) {
+    return Result(
+        "Vulkan: Device::Initialize given physical device does not support "
+        "required extensions");
   }
 
   ptrs_.vkGetPhysicalDeviceProperties(physical_device_,
@@ -625,222 +345,5 @@ Result Device::Initialize(PFN_vkGetInstanceProcAddr getInstanceProcAddr,
   return {};
 }
 
-bool Device::ChooseQueueFamilyIndex(const VkPhysicalDevice& physical_device) {
-  uint32_t count;
-  std::vector<VkQueueFamilyProperties> properties;
-
-  ptrs_.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count,
-                                                 nullptr);
-  properties.resize(count);
-
-  ptrs_.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count,
-                                                 properties.data());
-
-  for (uint32_t i = 0; i < count; ++i) {
-    if (properties[i].queueFlags &
-        (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)) {
-      queue_family_index_ = i;
-      return true;
-    }
-  }
-
-  return false;
-}
-
-Result Device::CreateInstance() {
-  VkApplicationInfo app_info = VkApplicationInfo();
-  app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
-  app_info.apiVersion = VK_MAKE_VERSION(1, 0, 0);
-
-  Result r = AreAllValidationLayersSupported();
-  if (!r.IsSuccess())
-    return r;
-
-  if (!AreAllValidationExtensionsSupported())
-    return Result("Vulkan: extensions of validation layers are not supported");
-
-  VkInstanceCreateInfo instance_info = VkInstanceCreateInfo();
-  instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
-  instance_info.pApplicationInfo = &app_info;
-  instance_info.enabledLayerCount = kNumberOfRequiredValidationLayers;
-  instance_info.ppEnabledLayerNames = kRequiredValidationLayers;
-  instance_info.enabledExtensionCount = 1U;
-  instance_info.ppEnabledExtensionNames = &kExtensionForValidationLayer;
-
-  if (ptrs_.vkCreateInstance(&instance_info, nullptr, &instance_) != VK_SUCCESS)
-    return Result("Vulkan::Calling vkCreateInstance Fail");
-
-  return {};
-}
-
-Result Device::CreateDebugReportCallback() {
-  VkDebugReportCallbackCreateInfoEXT info =
-      VkDebugReportCallbackCreateInfoEXT();
-  info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
-  info.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
-  info.pfnCallback = debugCallback;
-
-  if (ptrs_.vkCreateDebugReportCallbackEXT(instance_, &info, nullptr,
-                                           &callback_) != VK_SUCCESS) {
-    return Result("Vulkan: vkCreateDebugReportCallbackEXT fail");
-  }
-  return {};
-}
-
-Result Device::ChoosePhysicalDevice(
-    const std::vector<Feature>& required_features,
-    const std::vector<std::string>& required_extensions) {
-  uint32_t count;
-  std::vector<VkPhysicalDevice> physical_devices;
-
-  if (ptrs_.vkEnumeratePhysicalDevices(instance_, &count, nullptr) !=
-      VK_SUCCESS) {
-    return Result("Vulkan::Calling vkEnumeratePhysicalDevices Fail");
-  }
-
-  physical_devices.resize(count);
-  if (ptrs_.vkEnumeratePhysicalDevices(instance_, &count,
-                                       physical_devices.data()) != VK_SUCCESS) {
-    return Result("Vulkan::Calling vkEnumeratePhysicalDevices Fail");
-  }
-
-  for (uint32_t i = 0; i < count; ++i) {
-    VkPhysicalDeviceFeatures available_features = VkPhysicalDeviceFeatures();
-    ptrs_.vkGetPhysicalDeviceFeatures(physical_devices[i], &available_features);
-    if (!AreAllRequiredFeaturesSupported(available_features,
-                                         required_features)) {
-      continue;
-    }
-
-    if (!AreAllExtensionsSupported(GetAvailableExtensions(physical_devices[i]),
-                                   required_extensions)) {
-      continue;
-    }
-
-    if (ChooseQueueFamilyIndex(physical_devices[i])) {
-      physical_device_ = physical_devices[i];
-      return {};
-    }
-  }
-
-  return Result("Vulkan::No physical device supports Vulkan");
-}
-
-Result Device::CreateDevice(
-    const std::vector<Feature>& required_features,
-    const std::vector<std::string>& required_extensions) {
-  VkDeviceQueueCreateInfo queue_info = VkDeviceQueueCreateInfo();
-  const float priorities[] = {1.0f};
-  queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-  queue_info.queueFamilyIndex = queue_family_index_;
-  queue_info.queueCount = 1;
-  queue_info.pQueuePriorities = priorities;
-
-  VkDeviceCreateInfo info = VkDeviceCreateInfo();
-  info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
-  info.pQueueCreateInfos = &queue_info;
-  info.queueCreateInfoCount = 1;
-  // TODO(jaebaek): Enable layers
-  VkPhysicalDeviceFeatures requested_features =
-      RequestedFeatures(required_features);
-  info.pEnabledFeatures = &requested_features;
-
-  std::vector<const char*> enabled_extensions;
-  for (size_t i = 0; i < required_extensions.size(); ++i)
-    enabled_extensions.push_back(required_extensions[i].c_str());
-  info.enabledExtensionCount = static_cast<uint32_t>(enabled_extensions.size());
-  info.ppEnabledExtensionNames = enabled_extensions.data();
-
-  if (ptrs_.vkCreateDevice(physical_device_, &info, nullptr, &device_) !=
-      VK_SUCCESS) {
-    return Result("Vulkan::Calling vkCreateDevice Fail");
-  }
-
-  return {};
-}
-
-std::vector<std::string> Device::GetAvailableExtensions(
-    const VkPhysicalDevice& physical_device) {
-  std::vector<std::string> available_extensions;
-  uint32_t available_extension_count = 0;
-  std::vector<VkExtensionProperties> available_extension_properties;
-
-  if (ptrs_.vkEnumerateDeviceExtensionProperties(physical_device, nullptr,
-                                                 &available_extension_count,
-                                                 nullptr) != VK_SUCCESS) {
-    return available_extensions;
-  }
-
-  if (available_extension_count == 0)
-    return available_extensions;
-
-  available_extension_properties.resize(available_extension_count);
-  if (ptrs_.vkEnumerateDeviceExtensionProperties(
-          physical_device, nullptr, &available_extension_count,
-          available_extension_properties.data()) != VK_SUCCESS) {
-    return available_extensions;
-  }
-
-  for (const auto& property : available_extension_properties)
-    available_extensions.push_back(property.extensionName);
-
-  return available_extensions;
-}
-
-Result Device::AreAllValidationLayersSupported() {
-  std::vector<VkLayerProperties> available_layer_properties;
-  uint32_t available_layer_count = 0;
-  if (ptrs_.vkEnumerateInstanceLayerProperties(&available_layer_count,
-                                               nullptr) != VK_SUCCESS) {
-    return Result("Vulkan: vkEnumerateInstanceLayerProperties fail");
-  }
-  available_layer_properties.resize(available_layer_count);
-  if (ptrs_.vkEnumerateInstanceLayerProperties(
-          &available_layer_count, available_layer_properties.data()) !=
-      VK_SUCCESS) {
-    return Result("Vulkan: vkEnumerateInstanceLayerProperties fail");
-  }
-
-  std::set<std::string> required_layer_set(
-      kRequiredValidationLayers,
-      &kRequiredValidationLayers[kNumberOfRequiredValidationLayers]);
-  for (const auto& property : available_layer_properties) {
-    required_layer_set.erase(property.layerName);
-  }
-
-  if (required_layer_set.empty())
-    return {};
-
-  std::string missing_layers;
-  for (const auto& missing_layer : required_layer_set)
-    missing_layers = missing_layers + missing_layer + ",\n\t\t";
-  return Result("Vulkan: missing validation layers:\n\t\t" + missing_layers);
-}
-
-bool Device::AreAllValidationExtensionsSupported() {
-  for (const auto& layer : kRequiredValidationLayers) {
-    uint32_t available_extension_count = 0;
-    std::vector<VkExtensionProperties> extension_properties;
-
-    if (ptrs_.vkEnumerateInstanceExtensionProperties(
-            layer, &available_extension_count, nullptr) != VK_SUCCESS) {
-      return false;
-    }
-    extension_properties.resize(available_extension_count);
-    if (ptrs_.vkEnumerateInstanceExtensionProperties(
-            layer, &available_extension_count, extension_properties.data()) !=
-        VK_SUCCESS) {
-      return false;
-    }
-
-    for (const auto& ext : extension_properties) {
-      if (!strcmp(kExtensionForValidationLayer, ext.extensionName))
-        return true;
-    }
-  }
-
-  return false;
-}
-
 }  // namespace vulkan
 }  // namespace amber
diff --git a/src/vulkan/device.h b/src/vulkan/device.h
index 6a36272..656a7d2 100644
--- a/src/vulkan/device.h
+++ b/src/vulkan/device.h
@@ -28,15 +28,12 @@ namespace vulkan {
 
 struct VulkanPtrs {
 #define AMBER_VK_FUNC(func) PFN_##func func;
-#define AMBER_VK_GLOBAL_FUNC(func) PFN_##func func;
 #include "src/vulkan/vk-funcs.inc"
-#undef AMBER_VK_GLOBAL_FUNC
 #undef AMBER_VK_FUNC
 };
 
 class Device {
  public:
-  Device();
   Device(VkInstance instance,
          VkPhysicalDevice physical_device,
          const VkPhysicalDeviceFeatures& available_features,
@@ -49,7 +46,6 @@ class Device {
   Result Initialize(PFN_vkGetInstanceProcAddr getInstanceProcAddr,
                     const std::vector<Feature>& required_features,
                     const std::vector<std::string>& required_extensions);
-  void Shutdown();
 
   VkInstance GetInstance() const { return instance_; }
   VkPhysicalDevice GetPhysicalDevice() { return physical_device_; }
@@ -67,39 +63,9 @@ class Device {
   const VulkanPtrs* GetPtrs() const { return &ptrs_; }
 
  private:
-  Result LoadVulkanGlobalPointers(PFN_vkGetInstanceProcAddr);
   Result LoadVulkanPointers(PFN_vkGetInstanceProcAddr);
-  Result CreateInstance();
-  Result CreateDebugReportCallback();
-
-  // Get a physical device by checking if the physical device has a proper
-  // queue family, required features, and required extensions. Note that
-  // this method calls ChooseQueueFamilyIndex() to check if any queue
-  // provided by the physical device supports graphics or compute pipeline
-  // and sets |queue_family_index_| for the proper queue family.
-  Result ChoosePhysicalDevice(
-      const std::vector<Feature>& required_features,
-      const std::vector<std::string>& required_extensions);
-
-  // Return true if |physical_device| has a queue family that supports both
-  // graphics and compute or only a compute pipeline. If the proper queue
-  // family exists, |queue_family_index_| will have the queue family index
-  // and flags, respectively. Return false if the proper queue family does
-  // not exist.
-  bool ChooseQueueFamilyIndex(const VkPhysicalDevice& physical_device);
-
-  // Create a logical device with enabled features |required_features|
-  // and enabled extensions|required_extensions|.
-  Result CreateDevice(const std::vector<Feature>& required_features,
-                      const std::vector<std::string>& required_extensions);
-
-  std::vector<std::string> GetAvailableExtensions(
-      const VkPhysicalDevice& physical_device);
-  Result AreAllValidationLayersSupported();
-  bool AreAllValidationExtensionsSupported();
 
   VkInstance instance_ = VK_NULL_HANDLE;
-  VkDebugReportCallbackEXT callback_ = VK_NULL_HANDLE;
   VkPhysicalDevice physical_device_ = VK_NULL_HANDLE;
   VkPhysicalDeviceProperties physical_device_properties_;
   VkPhysicalDeviceMemoryProperties physical_memory_properties_;
@@ -107,16 +73,12 @@ class Device {
   std::vector<std::string> available_physical_device_extensions_;
   uint32_t queue_family_index_ = 0;
   VkDevice device_ = VK_NULL_HANDLE;
-
   VkQueue queue_ = VK_NULL_HANDLE;
 
-  bool destroy_device_ = true;
-
   VulkanPtrs ptrs_;
 };
 
 }  // namespace vulkan
-
 }  // namespace amber
 
 #endif  // SRC_VULKAN_DEVICE_H_
diff --git a/src/vulkan/engine_vulkan.cc b/src/vulkan/engine_vulkan.cc
index f3f84e0..cddac31 100644
--- a/src/vulkan/engine_vulkan.cc
+++ b/src/vulkan/engine_vulkan.cc
@@ -69,21 +69,17 @@ Result EngineVulkan::Initialize(EngineConfig* config,
   VulkanEngineConfig* vk_config = static_cast<VulkanEngineConfig*>(config);
   if (!vk_config || vk_config->vkGetInstanceProcAddr == VK_NULL_HANDLE)
     return Result("Vulkan::Initialize vkGetInstanceProcAddr must be provided.");
-
-  // If the device is provided, the physical_device and queue are also required.
-  if (vk_config->device != VK_NULL_HANDLE) {
-    if (vk_config->physical_device == VK_NULL_HANDLE)
-      return Result("Vulkan::Initialize physical device handle is null.");
-    if (vk_config->queue == VK_NULL_HANDLE)
-      return Result("Vulkan::Initialize queue handle is null.");
-
-    device_ = MakeUnique<Device>(
-        vk_config->instance, vk_config->physical_device,
-        vk_config->available_features, vk_config->available_extensions,
-        vk_config->queue_family_index, vk_config->device, vk_config->queue);
-  } else {
-    device_ = MakeUnique<Device>();
-  }
+  if (vk_config->device == VK_NULL_HANDLE)
+    return Result("Vulkan::Initialize device must be provided");
+  if (vk_config->physical_device == VK_NULL_HANDLE)
+    return Result("Vulkan::Initialize physical device handle is null.");
+  if (vk_config->queue == VK_NULL_HANDLE)
+    return Result("Vulkan::Initialize queue handle is null.");
+
+  device_ = MakeUnique<Device>(
+      vk_config->instance, vk_config->physical_device,
+      vk_config->available_features, vk_config->available_extensions,
+      vk_config->queue_family_index, vk_config->device, vk_config->queue);
 
   Result r = device_->Initialize(vk_config->vkGetInstanceProcAddr, features,
                                  extensions);
@@ -135,7 +131,6 @@ Result EngineVulkan::Shutdown() {
   if (pool_)
     pool_->Shutdown();
 
-  device_->Shutdown();
   return {};
 }
 
diff --git a/src/vulkan/log.cc b/src/vulkan/log.cc
deleted file mode 100644
index 32ae55e..0000000
--- a/src/vulkan/log.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/vulkan/log.h"
-
-#include <string>
-
-#ifdef __ANDROID__
-#include <android/log.h>
-#else  // __ANDROID__
-#include <iostream>
-#endif  // __ANDROID__
-
-namespace amber {
-namespace vulkan {
-namespace {
-
-#ifdef __ANDROID__
-const char* kTAG = "Amber";
-#endif  // __ANDROID__
-
-}  // namespace
-
-void LogError(const std::string& msg) {
-#ifdef __ANDROID__
-  ((void)__android_log_print(ANDROID_LOG_ERROR, kTAG, "%s", msg.c_str()));
-#else   // __ANDROID__
-  std::cerr << msg << std::endl << std::flush;
-#endif  // __ANDROID__
-}
-
-}  // namespace vulkan
-}  // namespace amber
diff --git a/src/vulkan/log.h b/src/vulkan/log.h
deleted file mode 100644
index c624590..0000000
--- a/src/vulkan/log.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2018 The Amber Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_VULKAN_LOG_H_
-#define SRC_VULKAN_LOG_H_
-
-#include <string>
-
-namespace amber {
-namespace vulkan {
-
-// This method is used for debug reports from Vulkan validation layers.
-void LogError(const std::string& msg);
-
-}  // namespace vulkan
-}  // namespace amber
-
-#endif  // SRC_VULKAN_LOG_H_
diff --git a/src/vulkan/vk-funcs.inc b/src/vulkan/vk-funcs.inc
index cf9df46..ca2f2c5 100644
--- a/src/vulkan/vk-funcs.inc
+++ b/src/vulkan/vk-funcs.inc
@@ -22,10 +22,8 @@ AMBER_VK_FUNC(vkCreateBuffer)
 AMBER_VK_FUNC(vkCreateBufferView)
 AMBER_VK_FUNC(vkCreateCommandPool)
 AMBER_VK_FUNC(vkCreateComputePipelines)
-AMBER_VK_FUNC(vkCreateDebugReportCallbackEXT)
 AMBER_VK_FUNC(vkCreateDescriptorPool)
 AMBER_VK_FUNC(vkCreateDescriptorSetLayout)
-AMBER_VK_FUNC(vkCreateDevice)
 AMBER_VK_FUNC(vkCreateFence)
 AMBER_VK_FUNC(vkCreateFramebuffer)
 AMBER_VK_FUNC(vkCreateGraphicsPipelines)
@@ -37,33 +35,24 @@ AMBER_VK_FUNC(vkCreateShaderModule)
 AMBER_VK_FUNC(vkDestroyBuffer)
 AMBER_VK_FUNC(vkDestroyBufferView)
 AMBER_VK_FUNC(vkDestroyCommandPool)
-AMBER_VK_FUNC(vkDestroyDebugReportCallbackEXT)
 AMBER_VK_FUNC(vkDestroyDescriptorPool)
 AMBER_VK_FUNC(vkDestroyDescriptorSetLayout)
-AMBER_VK_FUNC(vkDestroyDevice)
 AMBER_VK_FUNC(vkDestroyFence)
 AMBER_VK_FUNC(vkDestroyFramebuffer)
 AMBER_VK_FUNC(vkDestroyImage)
 AMBER_VK_FUNC(vkDestroyImageView)
-AMBER_VK_FUNC(vkDestroyInstance)
 AMBER_VK_FUNC(vkDestroyPipeline)
 AMBER_VK_FUNC(vkDestroyPipelineLayout)
 AMBER_VK_FUNC(vkDestroyRenderPass)
 AMBER_VK_FUNC(vkDestroyShaderModule)
 AMBER_VK_FUNC(vkEndCommandBuffer)
-AMBER_VK_FUNC(vkEnumerateDeviceExtensionProperties)
-AMBER_VK_FUNC(vkEnumeratePhysicalDevices)
 AMBER_VK_FUNC(vkFreeCommandBuffers)
 AMBER_VK_FUNC(vkFreeMemory)
 AMBER_VK_FUNC(vkGetBufferMemoryRequirements)
-AMBER_VK_FUNC(vkGetDeviceQueue)
 AMBER_VK_FUNC(vkGetImageMemoryRequirements)
-AMBER_VK_FUNC(vkGetInstanceProcAddr)
-AMBER_VK_FUNC(vkGetPhysicalDeviceFeatures)
 AMBER_VK_FUNC(vkGetPhysicalDeviceFormatProperties)
 AMBER_VK_FUNC(vkGetPhysicalDeviceMemoryProperties)
 AMBER_VK_FUNC(vkGetPhysicalDeviceProperties)
-AMBER_VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties)
 AMBER_VK_FUNC(vkMapMemory)
 AMBER_VK_FUNC(vkQueueSubmit)
 AMBER_VK_FUNC(vkResetCommandBuffer)
@@ -71,7 +60,3 @@ AMBER_VK_FUNC(vkResetFences)
 AMBER_VK_FUNC(vkUnmapMemory)
 AMBER_VK_FUNC(vkUpdateDescriptorSets)
 AMBER_VK_FUNC(vkWaitForFences)
-
-AMBER_VK_GLOBAL_FUNC(vkCreateInstance)
-AMBER_VK_GLOBAL_FUNC(vkEnumerateInstanceExtensionProperties)
-AMBER_VK_GLOBAL_FUNC(vkEnumerateInstanceLayerProperties)