Consistently refer to C++ as "cpp" and fix installation

1 files changed, 168 insertions, 0 deletions

diff --git a/bindings/cpp/include/pugl/vulkan.hpp b/bindings/cpp/include/pugl/vulkan.hpp
new file mode 100644
index 0000000..d65b2d6
--- /dev/null
+++ b/bindings/cpp/include/pugl/vulkan.hpp
@@ -0,0 +1,168 @@
+/*
+  Copyright 2012-2020 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/*
+  Note that this header includes Vulkan headers, so if you are writing a
+  program or plugin that dynamically loads vulkan, you should first define
+  `VK_NO_PROTOTYPES` before including it.
+*/
+
+#ifndef PUGL_VULKAN_HPP
+#define PUGL_VULKAN_HPP
+
+#include "pugl/pugl.h"
+#include "pugl/pugl.hpp"
+#include "pugl/vulkan.h"
+
+#include <vulkan/vulkan_core.h>
+
+#include <cstdint>
+
+namespace pugl {
+
+/**
+   @defgroup vulkanpp Vulkan
+   Vulkan graphics support.
+
+   Note that the Pugl C++ wrapper does not use vulkan-hpp because it is a
+   heavyweight dependency which not everyone uses, and its design is not very
+   friendly to dynamic loading in plugins anyway.  However, if you do use
+   vulkan-hpp smart handles, it is relatively straightforward to wrap the
+   result of createSurface() manually.
+
+   @ingroup puglpp
+   @{
+*/
+
+/// @copydoc PuglVulkanLoader
+class VulkanLoader final
+  : public detail::Wrapper<PuglVulkanLoader, puglFreeVulkanLoader>
+{
+public:
+  /**
+     Create a new dynamic loader for Vulkan functions.
+
+     This dynamically loads the Vulkan library and gets the load functions
+     from it.
+
+     Note that this constructor does not throw exceptions, though failure is
+     possible.  To check if the Vulkan library failed to load, test this
+     loader, which is explicitly convertible to `bool`.  It is safe to use a
+     failed loader, but the accessors will always return null.
+  */
+  explicit VulkanLoader(World& world) noexcept
+    : Wrapper{puglNewVulkanLoader(world.cobj())}
+  {}
+
+  /**
+     Return the `vkGetInstanceProcAddr` function.
+
+     @return Null if the Vulkan library failed to load, or does not contain
+     this function (which is unlikely and indicates a broken system).
+  */
+  PFN_vkGetInstanceProcAddr getInstanceProcAddrFunc() const noexcept
+  {
+    return cobj() ? puglGetInstanceProcAddrFunc(cobj()) : nullptr;
+  }
+
+  /**
+     Return the `vkGetDeviceProcAddr` function.
+
+     @return Null if the Vulkan library failed to load, or does not contain
+     this function (which is unlikely and indicates a broken system).
+  */
+  PFN_vkGetDeviceProcAddr getDeviceProcAddrFunc() const noexcept
+  {
+    return cobj() ? puglGetDeviceProcAddrFunc(cobj()) : nullptr;
+  }
+
+  /// Return true if this loader is valid to use
+  explicit operator bool() const noexcept { return cobj(); }
+};
+
+/**
+   A simple wrapper for an array of static C strings.
+
+   This provides a minimal API that supports iteration, like `std::vector`, but
+   avoids allocation, exceptions, and a dependency on the C++ standard library.
+*/
+class StaticStringArray final
+{
+public:
+  using value_type     = const char*;
+  using const_iterator = const char* const*;
+  using size_type      = uint32_t;
+
+  StaticStringArray(const char* const* strings, const uint32_t size) noexcept
+    : _strings{strings}
+    , _size{size}
+  {}
+
+  const char* const* begin() const noexcept { return _strings; }
+  const char* const* end() const noexcept { return _strings + _size; }
+  const char* const* data() const noexcept { return _strings; }
+  uint32_t           size() const noexcept { return _size; }
+
+private:
+  const char* const* _strings;
+  uint32_t           _size;
+};
+
+/**
+   Return the Vulkan instance extensions required to draw to a PuglView.
+
+   If successful, the returned array always contains "VK_KHR_surface", along
+   with whatever other platform-specific extensions are required.
+
+   @return An array of extension name strings.
+*/
+inline StaticStringArray
+getInstanceExtensions() noexcept
+{
+  uint32_t                 count      = 0;
+  const char* const* const extensions = puglGetInstanceExtensions(&count);
+
+  return StaticStringArray{extensions, count};
+}
+
+/// @copydoc puglCreateSurface
+inline VkResult
+createSurface(PFN_vkGetInstanceProcAddr          vkGetInstanceProcAddr,
+              View&                              view,
+              VkInstance                         instance,
+              const VkAllocationCallbacks* const allocator,
+              VkSurfaceKHR* const                surface) noexcept
+{
+  const VkResult r = puglCreateSurface(
+    vkGetInstanceProcAddr, view.cobj(), instance, allocator, surface);
+
+  return (!r && !surface) ? VK_ERROR_INITIALIZATION_FAILED : r;
+}
+
+/// @copydoc puglVulkanBackend
+inline const PuglBackend*
+vulkanBackend() noexcept
+{
+  return puglVulkanBackend();
+}
+
+/**
+   @}
+*/
+
+} // namespace pugl
+
+#endif // PUGL_VULKAN_HPP