Graphics engine written in Metal & Swift.
It's an endless work-in-progress that I use in my spare to test things. It should be usable to do basic stuff, but note that there are no plans for OpenGL ES support, and thus, both older devices and the simulators are not supported. You will need a Metal-compatible iOS device to build and run it.
Simply add this repository as a submodule in your repository,
git submodule add firstname.lastname@example.org:endavid/VidEngine.git VidEngine
- Create a Workspace in Xcode
- Add your project to the workspace
- An easy way to start is to create a Single View App from the iOS templates (File → New → Project).
- Under Target → Build Phases, add MetalKit.framework to
Link binary with librariessection.
Main.storyboard, select the
View, and select
MTKViewclass in the Identity inspector.
- Add VidFramework project to the workspace: Add Files → select
- If you want to check the shaders, also add VidMetalLib to your workspace. But note that at the moment, you need to build the shader libraries from the console (see Build section).
- I would also add a sample app to your workspace. For instance, if you want to create an AR app, add SampleAR to your workspace.
- Select your project in Xcode, and in Target → General → Embedded Binaries, select VidFramework (it should appear if it's in your workspace). This should also add it to Linked Framework & Libraries. But if it doesn't, add it there as well. Also make sure it did add an entry in Build Phases → Embed Frameworks.
Use the provided
build.sh, because I can't figure out how to get the shaders in VidMetalLib to get linked to the correct location from Xcode...
This engine is Metal-only, so that needs to be specified as a requirement in your Info.plist. If you are going to use AR, you will also need to include
arkit to the list. Your
Info.plist should have this section,
<key>UIRequiredDeviceCapabilities</key> <array> <string>armv7</string> <string>metal</string> <string>arkit</string> </array>
Vid Engine uses a right-handed coordinate system, with
Y being the vertical direction. The camera looks to
-Z by default. That means that
+Z points towards the screen, and
+X towards the right side of the screen. Units are given in meters by default. Therefore, both coordinate system and units match ARKit, so working with AR scene should be straightforward.
Open the VidWorkspace and you should see several samples.
ARKit sample app using the VidEngine.
Details in these posts:
- Spherical Harmonics Lighting from ARKit Environment Probes
- How to combine Render Command Encoders that use a different shader in Metal
Example of using display-P3 color space, and Self-Organizing Maps (a type of neural network).
Read these blog posts:
Also, this sample has been expanded into a full app: Palettist
This is just the typical cornell box scene (WIP)
Very simple procedural 2D rain. All the updates happen in the GPU with a compute shader. You can read about it in this blog post: Metal: a Swift Introduction
If you need a more minimalistic example, find the
rain-demo tag in git history.
This demonstrates the support of font rendering in the 3D world using Signed-Distance Fields.
GPU Quaternions performance tests
You need to find these tags in the commit history:
instanced-spheres-quaternions instanced-sphere-matrices instanced-cubes-quaternions instanced-cubes-matrices cubes-demo-quaternions cubes-demo-matrices
Just examples of instancing and GPU quaternions. Read about it in detail in this blog post: Performance of quaternions in the GPU
MIT License. Please let me know if you use this in any of your projects.