Added missing functions for compatibility with Vulkan

v3.3/glfw/glfw/deps/vulkan/vk_platform.h

@@ -0,0 +1,120 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright (c) 2014-2015 The Khronos Group Inc.
+**
+** 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 VK_PLATFORM_H_
+#define VK_PLATFORM_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+***************************************************************************************************
+*   Platform-specific directives and type declarations
+***************************************************************************************************
+*/
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that Vulkan clients call Vulkan commands
+ * with the same calling conventions that the Vulkan implementation expects.
+ *
+ * VKAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * VKAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
+ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
+ */
+#if defined(_WIN32)
+    // On Windows, Vulkan commands use the stdcall convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL __stdcall
+    #define VKAPI_PTR  VKAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
+    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && __ARM_32BIT_STATE
+    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
+    // calling convention, i.e. float parameters are passed in registers. This
+    // is true even if the rest of the application passes floats on the stack,
+    // as it does by default when compiling for the armeabi-v7a NDK ABI.
+    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+    #define VKAPI_CALL
+    #define VKAPI_PTR  VKAPI_ATTR
+#else
+    // On other platforms, use the default calling convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL
+    #define VKAPI_PTR
+#endif
+
+#include <stddef.h>
+
+#if !defined(VK_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(VK_NO_STDINT_H)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+// Platform-specific headers required by platform window system extensions.
+// These are enabled prior to #including "vulkan.h". The same enable then
+// controls inclusion of the extension interfaces in vulkan.h.
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#include <android/native_window.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+#include <mir_toolkit/client_types.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#endif
+
+#endif

v3.3/glfw/vulkan.go

@@ -1,8 +1,27 @@
 package glfw
 
-//#define GLFW_INCLUDE_NONE
-//#include "glfw/include/GLFW/glfw3.h"
+/*
+#include "glfw/include/GLFW/glfw3.h"
+#include "glfw/src/internal.h"
+
+GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);
+GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* procname);
+
+// Helper function for doing raw pointer arithmetic
+static inline const char* getArrayIndex(const char** array, unsigned int index) {
+	return array[index];
+}
+
+void* getVulkanProcAddr() {
+	return glfwGetInstanceProcAddress;
+}
+*/
 import "C"
+import (
+	"errors"
+	"reflect"
+	"unsafe"
+)
 
 // VulkanSupported reports whether the Vulkan loader has been found. This check is performed by Init.
 //
@@ -13,3 +32,54 @@ import "C"
 func VulkanSupported() bool {
 	return glfwbool(C.glfwVulkanSupported())
 }
+
+// GetVulkanGetInstanceProcAddress returns the function pointer used to find Vulkan core or
+// extension functions. The return value of this function can be passed to the Vulkan library.
+//
+// Note that this function does not work the same way as the glfwGetInstanceProcAddress.
+func GetVulkanGetInstanceProcAddress() unsafe.Pointer {
+	return C.getVulkanProcAddr()
+}
+
+// GetRequiredInstanceExtensions returns a slice of Vulkan instance extension names required
+// by GLFW for creating Vulkan surfaces for GLFW windows. If successful, the list will always
+// contain VK_KHR_surface, so if you don't require any additional extensions you can pass this list
+// directly to the VkInstanceCreateInfo struct.
+//
+// If Vulkan is not available on the machine, this function returns nil. Call
+// VulkanSupported to check whether Vulkan is available.
+//
+// If Vulkan is available but no set of extensions allowing window surface creation was found, this
+// function returns nil. You may still use Vulkan for off-screen rendering and compute work.
+func (window *Window) GetRequiredInstanceExtensions() []string {
+	var count C.uint32_t
+	strarr := C.glfwGetRequiredInstanceExtensions(&count)
+	if count == 0 {
+		return nil
+	}
+
+	extensions := make([]string, count)
+	for i := uint(0); i < uint(count); i++ {
+		extensions[i] = C.GoString(C.getArrayIndex(strarr, C.uint(i)))
+	}
+	return extensions
+}
+
+// CreateWindowSurface creates a Vulkan surface for this window.
+func (window *Window) CreateWindowSurface(instance interface{}, allocCallbacks unsafe.Pointer) (surface uintptr, err error) {
+	if instance == nil {
+		return 0, errors.New("vulkan: instance is nil")
+	}
+	val := reflect.ValueOf(instance)
+	if val.Kind() != reflect.Ptr {
+		return 0, errors.New("vulkan: instance is not a VkInstance (expected kind Ptr, got " + val.Kind().String() + ")")
+	}
+	var vulkanSurface C.VkSurfaceKHR
+	ret := C.glfwCreateWindowSurface(
+		(C.VkInstance)(unsafe.Pointer(reflect.ValueOf(instance).Pointer())), window.data,
+		(*C.VkAllocationCallbacks)(allocCallbacks), (*C.VkSurfaceKHR)(unsafe.Pointer(&vulkanSurface)))
+	if ret != C.VK_SUCCESS {
+		return 0, errors.New("vulkan: error creating window surface")
+	}
+	return uintptr(unsafe.Pointer(&vulkanSurface)), nil
+}