Programming on BlueHour

Notes on Developing Vulkan on Mac

Sat, 27 Sep 2025 00:00:00 +0000

Setup environment on MacOS

First, install the Vulkan SDK. I recommend downloading the latest version from the LunarG website. The default install path is usually /Users/$USER/VulkanSDK/version-number.
The SDK includes a script named setup-env.sh for setting environment variables, so you need to run it every time your shell starts.
Open your shell config file, such as _{/.zshrc for zsh or}/.bash_profile for bash, and add the following line. This gives every new shell session the corresponding Vulkan environment variables, and CMake can also find Vulkan through find_package.

# Note: replace this path with your actual VulkanSDK installation path
source /Users/USER/VulkanSDK/1.3.xxx.x/setup-env.sh

MoltenVK

Apple’s native graphics API is Metal, and there is no native Vulkan implementation on macOS. So you need MoltenVK to translate Vulkan calls into Metal calls. If you installed the Vulkan SDK, MoltenVK is already included. One extra thing to watch out for: when creating Vulkan-related contexts, there are three places you need to configure.

C#, Java, and Cpp Communication in Unity

Thu, 12 Sep 2024 00:00:00 +0000

This post covers four things:

How C# calls Java functions in Unity.
How Java calls C++ through JNI.
How C++ under JNI calls Java.
How Java calls Unity’s C#.

CSharp Call Java

Use Unity’s AndroidJavaObject, and pass the Java class object into the constructor. The format is the package name followed by the class name.

For example, in Java:

package com.example.jni;

public class ExampleJavaClass {
	// Function with no return value
	void TestFuncVoid(int a) { /* ... */ }
	// Function with a return value
	int TestFuncInt(int a) { /* ... */ }
}

In CSharp, write it like this:

Cross-Compiling C++ for Android Without Android Studio

Sun, 17 Dec 2023 00:00:00 +0000

AndroidCppCrossCompile

Android Studio has quite a few bugs, and the C++ development experience is not exactly great. A lot of the time, when we need to do JNI development or pure C++ development, we do not really want to do it inside Android Studio. So we need an environment for cross-compiling C++ programs for Android without relying on Android Studio.

Next, I will use CMake to build the whole workflow. First, the preparation: you must download the NDK, because we need to use the NDK toolchain. The version I use here is r23c.

Using Arm64 Assembly on Android

Mon, 16 Oct 2023 00:00:00 +0000

AndroidAsm

First, create an Android Studio JNI project. By default, the project will generate a C++ file that calls a native function from the Java side to display a string.

The function generated on the Cpp side uses static binding, so the function name is extremely long and not very pleasant to look at. Let’s change it to dynamic binding first. Start by renaming that verbose function.

JNIEXPORT jstring JNICALL StringFromJNI(JNIEnv *env, jclass clazz)
{
    std::string hello { "Hello World From JNI" };
    return env->NewStringUTF(hello.c_str());
}

Next, implement dynamic binding. Add a function called JniOnLoad to the Cpp file, and load the native function from the Java side inside this function.

Lock-Free Programming

Fri, 21 Apr 2023 00:00:00 +0000

Lock-Free Programming

The goal of lock-free programming is not to make synchronization “free”. It is to avoid as much of the extra overhead of traditional locks as possible in highly concurrent scenarios.

In a multithreaded environment, the most common and simplest synchronization tool is still a lock. For example, many implementations of std::mutex try to stay in user space when there is no contention. But once contention becomes heavy, threads may block, wake up, and context switch, and performance can drop sharply. Even when the kernel is not involved, locks can still introduce cache synchronization, pipeline stalls, and scheduling overhead.

Getting Started with OpenGL Using SFML

Fri, 22 Oct 2021 00:00:00 +0000

If you have ever taught yourself OpenGL, you probably remember the pain of pulling in a whole pile of libraries. GLEW and GLUT in particular are awkward to use. SFML makes opening a window very simple, and for anyone learning OpenGL, I think it can completely replace GLUT. So in this post I will use SFML to create the window, then write a casual OpenGL example: a simple forward renderer using the Phong model.