WIP Geometry shaders

.github/workflows/CI.yml

@@ -15,21 +15,17 @@ jobs:
   build:
     strategy:
       matrix:
-        xcode: [ "14.2" ]
-        platform: [ "macos", "maccat", "ios", "tvos" ]
-        os: [ "macos-latest" ]
+        xcode: [ "14.3.1" ]
+        platform: [ "all", "macos", "ios" ]
+        os: [ "macos-13" ]
         upload_artifacts: [ true ]
-        # additional specific configurations
+
+        # Legacy configurations
         include:
-          # "Legacy" Xcode 12.5.1 & 11.7 macOS builds
           - xcode: "12.5.1"
             platform: "macos"
             os: "macos-11"
             upload_artifacts: false
-          - xcode: "11.7"
-            platform: "macos"
-            os: "macos-11"
-            upload_artifacts: false
       fail-fast: false
 
     name: 'MoltenVK (Xcode ${{ matrix.xcode }} - ${{ matrix.platform }})'
@@ -41,7 +37,7 @@ jobs:
 
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Select Xcode version
         run: sudo xcode-select -switch "${XCODE_DEV_PATH}"
@@ -54,12 +50,12 @@ jobs:
           echo "${XCODE_VERSION}"
           XCODE_VERSION="$(echo "${XCODE_VERSION}" | tr '\t\r\n ' '_')"
           echo "${XCODE_VERSION}"
-          echo "::set-output name=XCODE_VERSION::${XCODE_VERSION}"
+          echo "XCODE_VERSION=${XCODE_VERSION}" >> $GITHUB_OUTPUT
 
       - name: Cache Dependencies
         id: cache-dependencies
         if: success() && !(github.event_name == 'push' && contains(github.ref, 'refs/tags/')) # never cache dependencies for pushed tags
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             External/build
@@ -94,11 +90,46 @@ jobs:
       - name: Tar Artifacts
         if: success() && matrix.upload_artifacts == true
         # See: https://github.com/actions/upload-artifact#maintaining-file-permissions-and-case-sensitive-files
-        run: tar -cvf "${{ matrix.platform }}.tar" Package/Release/
+        # To reduce artifact size, don't include any stand-alone shader converter binaries.
+        run: |
+          rm -rf Package/Release/MoltenVKShaderConverter
+          tar -C Package -s/Release/MoltenVK/ -cvf "MoltenVK-${{ matrix.platform }}.tar" Release/
 
       - name: Upload Artifacts
         if: success() && matrix.upload_artifacts == true
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
+        with:
+          name: "MoltenVK-${{ matrix.platform }}"
+          path: "MoltenVK-${{ matrix.platform }}.tar"
+
+  release:
+    name: 'Release'
+
+    needs: [build]
+
+    runs-on: ubuntu-latest
+
+    if: ${{ startsWith(github.ref, 'refs/tags/') }}
+
+    permissions:
+      contents: write
+
+    steps:
+      - name: Download Artifacts
+        uses: actions/download-artifact@v3
+
+      - name: Create Release
+        uses: ncipollo/release-action@v1
         with:
-          name: ${{ matrix.platform }}
-          path: "${{ matrix.platform }}.tar"
+          # Allow updating existing releases if the workflow is triggered by release creation or re-run.
+          allowUpdates: true
+          # When the release is updated, delete the existing artifacts for replacement.
+          removeArtifacts: true
+          # If a release is being replaced, omit updating the name and body.
+          # Allows for creating a release and filling these in before the workflow runs.
+          # Then, the workflow will populate the release with the artifacts.
+          omitNameDuringUpdate: true
+          omitBodyDuringUpdate: true
+          # Upload all MoltenVK CI artifacts as release assets.
+          artifacts: "MoltenVK*/*"
+          artifactErrorsFailBuild: true

Common/MVKCommonEnvironment.h

@@ -62,6 +62,14 @@ extern "C" {
 #	define MVK_TVOS					TARGET_OS_TV
 #endif
 
+/** Building for visionOS. */
+#ifndef TARGET_OS_XR
+#	define TARGET_OS_XR				0		// Older SDK's don't define TARGET_OS_XR
+#endif
+#ifndef MVK_VISIONOS
+#	define MVK_VISIONOS				TARGET_OS_XR
+#endif
+
 /** Building for iOS or tvOS. */
 #ifndef MVK_IOS_OR_TVOS
 #	define MVK_IOS_OR_TVOS			(MVK_IOS || MVK_TVOS)
@@ -72,6 +80,11 @@ extern "C" {
 #	define MVK_MACOS_OR_IOS			(MVK_MACOS || MVK_IOS)
 #endif
 
+/** Building for macOS, iOS or visionOS. */
+#ifndef MVK_MACOS_OR_IOS_OR_VISIONOS
+#	define MVK_MACOS_OR_IOS_OR_VISIONOS	(MVK_MACOS || MVK_IOS | MVK_VISIONOS)
+#endif
+
 /** Building for a Simulator. */
 #ifndef MVK_OS_SIMULATOR
 #	define MVK_OS_SIMULATOR			TARGET_OS_SIMULATOR
@@ -87,18 +100,26 @@ extern "C" {
 #	define MVK_MACOS_APPLE_SILICON	(MVK_MACOS && MVK_APPLE_SILICON)
 #endif
 
-/** Building with Xcode versions. */
+/** Building with Xcode versions. iOS version also covers tvOS. */
+#ifndef MVK_XCODE_15
+#   define MVK_XCODE_15             ((__MAC_OS_X_VERSION_MAX_ALLOWED >= 140000) || \
+                                    (__IPHONE_OS_VERSION_MAX_ALLOWED >= 170000))
+#endif
+#ifndef MVK_XCODE_14_3
+#	define MVK_XCODE_14_3			((__MAC_OS_X_VERSION_MAX_ALLOWED >= 130300) || \
+									(__IPHONE_OS_VERSION_MAX_ALLOWED >= 160400))
+#endif
 #ifndef MVK_XCODE_14
 #	define MVK_XCODE_14				((__MAC_OS_X_VERSION_MAX_ALLOWED >= 130000) || \
-									(__IPHONE_OS_VERSION_MAX_ALLOWED >= 160000))   // Also covers tvOS
+									(__IPHONE_OS_VERSION_MAX_ALLOWED >= 160000))
 #endif
 #ifndef MVK_XCODE_13
 #	define MVK_XCODE_13 			((__MAC_OS_X_VERSION_MAX_ALLOWED >= 120000) || \
-									 (__IPHONE_OS_VERSION_MAX_ALLOWED >= 150000))	// Also covers tvOS
+									 (__IPHONE_OS_VERSION_MAX_ALLOWED >= 150000))
 #endif
 #ifndef MVK_XCODE_12
-#	define MVK_XCODE_12 			((__MAC_OS_X_VERSION_MAX_ALLOWED >= 101600) || \
-									 (__IPHONE_OS_VERSION_MAX_ALLOWED >= 140000))	// Also covers tvOS
+#	define MVK_XCODE_12 			((__MAC_OS_X_VERSION_MAX_ALLOWED >= 110000) || \
+									 (__IPHONE_OS_VERSION_MAX_ALLOWED >= 140000))
 #endif
 
 /** Directive to identify public symbols. */

Common/MVKOSExtensions.h

@@ -52,11 +52,13 @@ inline bool mvkOSVersionIsAtLeast(MVKOSVersion minVer) { return mvkOSVersion() >
  * to always fail on that OS, which is useful for indidicating functionalty guarded by
  * this test is not supported on that OS.
  */
-inline bool mvkOSVersionIsAtLeast(MVKOSVersion macOSMinVer, MVKOSVersion iOSMinVer) {
+inline bool mvkOSVersionIsAtLeast(MVKOSVersion macOSMinVer, MVKOSVersion iOSMinVer, MVKOSVersion visionOSMinVer) {
 #if MVK_MACOS
 	return mvkOSVersionIsAtLeast(macOSMinVer);
 #endif
-#if MVK_IOS_OR_TVOS
+#if MVK_VISIONOS
+	return mvkOSVersionIsAtLeast(visionOSMinVer);
+#elif MVK_IOS_OR_TVOS
 	return mvkOSVersionIsAtLeast(iOSMinVer);
 #endif
 }
@@ -76,6 +78,14 @@ uint64_t mvkGetTimestamp();
 /** Returns the number of nanoseconds between each increment of the value returned by mvkGetTimestamp(). */
 double mvkGetTimestampPeriod();
 
+/**
+ * Returns the number of nanoseconds elapsed between startTimestamp and endTimestamp,
+ * each of which should be a value returned by mvkGetTimestamp().
+ * If endTimestamp is zero or not supplied, it is taken to be the current time.
+ * If startTimestamp is zero or not supplied, it is taken to be the time the app was initialized.
+ */
+uint64_t mvkGetElapsedNanoseconds(uint64_t startTimestamp = 0, uint64_t endTimestamp = 0);
+
 /**
  * Returns the number of milliseconds elapsed between startTimestamp and endTimestamp,
  * each of which should be a value returned by mvkGetTimestamp().
@@ -84,6 +94,9 @@ double mvkGetTimestampPeriod();
  */
 double mvkGetElapsedMilliseconds(uint64_t startTimestamp = 0, uint64_t endTimestamp = 0);
 
+/** Returns the current absolute time in nanoseconds. */
+uint64_t mvkGetAbsoluteTime();
+
 /** Ensures the block is executed on the main thread. */
 void mvkDispatchToMainAndWait(dispatch_block_t block);
 
@@ -164,3 +177,9 @@ uint64_t mvkGetUsedMemorySize();
 
 /** Returns the size of a page of host memory on this platform. */
 uint64_t mvkGetHostMemoryPageSize();
+
+#pragma mark -
+#pragma mark Threading
+
+/** Returns the amount of avaliable CPU cores. */
+uint32_t mvkGetAvaliableCPUCores();

Common/MVKOSExtensions.mm

@@ -40,16 +40,23 @@ MVKOSVersion mvkOSVersion() {
 
 static uint64_t _mvkTimestampBase;
 static double _mvkTimestampPeriod;
+static mach_timebase_info_data_t _mvkMachTimebase;
 
 uint64_t mvkGetTimestamp() { return mach_absolute_time() - _mvkTimestampBase; }
 
 double mvkGetTimestampPeriod() { return _mvkTimestampPeriod; }
 
-double mvkGetElapsedMilliseconds(uint64_t startTimestamp, uint64_t endTimestamp) {
+uint64_t mvkGetElapsedNanoseconds(uint64_t startTimestamp, uint64_t endTimestamp) {
 	if (endTimestamp == 0) { endTimestamp = mvkGetTimestamp(); }
-	return (double)(endTimestamp - startTimestamp) * _mvkTimestampPeriod / 1e6;
+	return (endTimestamp - startTimestamp) * _mvkTimestampPeriod;
+}
+
+double mvkGetElapsedMilliseconds(uint64_t startTimestamp, uint64_t endTimestamp) {
+	return mvkGetElapsedNanoseconds(startTimestamp, endTimestamp) / 1e6;
 }
 
+uint64_t mvkGetAbsoluteTime() { return mach_continuous_time() * _mvkMachTimebase.numer / _mvkMachTimebase.denom; }
+
 // Initialize timestamping capabilities on app startup.
 //Called automatically when the framework is loaded and initialized.
 static bool _mvkTimestampsInitialized = false;
@@ -58,9 +65,8 @@ MVKOSVersion mvkOSVersion() {
 	_mvkTimestampsInitialized = true;
 
 	_mvkTimestampBase = mach_absolute_time();
-	mach_timebase_info_data_t timebase;
-	mach_timebase_info(&timebase);
-	_mvkTimestampPeriod = (double)timebase.numer / (double)timebase.denom;
+	mach_timebase_info(&_mvkMachTimebase);
+	_mvkTimestampPeriod = (double)_mvkMachTimebase.numer / (double)_mvkMachTimebase.denom;
 }
 
 void mvkDispatchToMainAndWait(dispatch_block_t block) {
@@ -97,7 +103,7 @@ bool mvkGetEnvVarBool(std::string varName, bool* pWasFound) {
 #pragma mark System memory
 
 uint64_t mvkGetSystemMemorySize() {
-#if MVK_MACOS_OR_IOS
+#if MVK_MACOS_OR_IOS_OR_VISIONOS
 	mach_msg_type_number_t host_size = HOST_BASIC_INFO_COUNT;
 	host_basic_info_data_t info;
 	if (host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&info, &host_size) == KERN_SUCCESS) {
@@ -138,3 +144,10 @@ uint64_t mvkGetUsedMemorySize() {
 
 uint64_t mvkGetHostMemoryPageSize() { return sysconf(_SC_PAGESIZE); }
 
+#pragma mark -
+#pragma mark Threading
+
+/** Returns the amount of avaliable CPU cores. */
+uint32_t mvkGetAvaliableCPUCores() {
+    return (uint32_t)[[NSProcessInfo processInfo] activeProcessorCount];
+}

Common/MVKStrings.h

@@ -21,6 +21,8 @@
 
 #include <string>
 #include <streambuf>
+#include <vector>
+#include <cxxabi.h>
 
 namespace mvk {
 
@@ -59,6 +61,26 @@ namespace mvk {
 		return varName;
 	}
 
+	/** Returns a string containing the ordinal suffix for a numeric value.*/
+	inline const char* getOrdinalSuffix(int64_t val) {
+		static const char* suffixes[] = {"th", "st", "nd", "rd"};
+		auto ord = val % 100;
+		if (ord > 10 && ord < 20) { return suffixes[0]; }	// All teens end in th.
+		ord = ord % 10;
+		if (ord > 3) { return suffixes[0]; }	// 4-9 end in th.
+		return suffixes[ord];
+	}
+
+	/** Returns the name of a C++ type. */
+	template<typename T>
+	inline std::string getTypeName(const T* pObj) {
+		int status;
+		char* demangledName = abi::__cxa_demangle(typeid(*pObj).name(), 0, 0, &status);
+		std::string tName = demangledName;
+		free(demangledName);
+		return tName;
+	}
+
 
 #pragma mark -
 #pragma mark Streams

Demos/Cube/macOS/DemoViewController.m

@@ -43,13 +43,29 @@ -(void) viewDidLoad {
 
 	self.view.wantsLayer = YES;		// Back the view with a layer created by the makeBackingLayer method.
 
-	const char* argv[] = { "cube" };
+	// Enabling this will sync the rendering loop with the natural display link (60 fps).
+	// Disabling this will allow the rendering loop to run flat out, limited only by the rendering speed.
+	bool useDisplayLink = true;
+
+	VkPresentModeKHR vkPresentMode = useDisplayLink ? VK_PRESENT_MODE_FIFO_KHR : VK_PRESENT_MODE_IMMEDIATE_KHR;
+	char vkPresentModeStr[64];
+	sprintf(vkPresentModeStr, "%d", vkPresentMode);
+
+	const char* argv[] = { "cube", "--present_mode", vkPresentModeStr };
 	int argc = sizeof(argv)/sizeof(char*);
 	demo_main(&demo, self.view.layer, argc, argv);
 
-	CVDisplayLinkCreateWithActiveCGDisplays(&_displayLink);
-	CVDisplayLinkSetOutputCallback(_displayLink, &DisplayLinkCallback, &demo);
-	CVDisplayLinkStart(_displayLink);
+	if (useDisplayLink) {
+		CVDisplayLinkCreateWithActiveCGDisplays(&_displayLink);
+		CVDisplayLinkSetOutputCallback(_displayLink, &DisplayLinkCallback, &demo);
+		CVDisplayLinkStart(_displayLink);
+	} else {
+		dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+			while(true) {
+				demo_draw(&demo);
+			}
+		});
+	}
 }