Home on Arjo Nagelhout

Basis splines

Tue, 07 Apr 2026 01:00:00 +0000

How are smooth and complex curves and curved surfaces constructed in computers for computer-aided design (CAD)? With splines!

Compared to simpler definitions such as arcs, polynomials, lines, planes, spheres and cylinders, splines allow creating smooth, complex curves and surfaces from a set of control points. Because of this, splines are unmissable in creating organic shapes in products and architecture.

Minimal sudoku solver using DFS in C++

Mon, 06 Apr 2026 00:00:00 +0000

Sometimes I take the time to sit down and solve some sudoku puzzles. I never got into more advanced techniques, such as X-wings, so as I was staring at a seemingly impossible sudoku passage, I wondered; How hard can it be to write an algorithm for this?

While the internet is full of sudoku solvers, the potential thrill of finding a solution myself made me refrain from looking up known techniques. Admittedly, I did get stuck at one point attempting to traverse all possible paths towards a solution, which is a much larger search space than filling in cells sequentially. A quick look at a video of the backtracking algorithm in action got me back on track, but now I can’t claim to have solved it fully on my own.

Tree traversal without using the built-in stack in C++

Mon, 26 Jan 2026 00:00:00 +0000

I have written these code snippets too often, so I might as well share them. The reason for not using recursion – and thus relying on the built-in stack – is that for large values for N, the stack trace will become hard to debug and read, and you might create a stack overflow if the stack size is set too conservatively.

The functions are templated, but they don’t have to be.

Importing IFC Geometry

Sun, 25 Jan 2026 19:00:00 +0000

In order for my 3D modeling application to be useful in the workflow of an architect, I need to be able to import and export document interchange formats such as IFC and STEP.

For that reason I wrote an IFC reader, which consists of an EXPRESS parser, an EXPRESS runtime, a STEP parser, a STEP reader and IFC-specific logic for iterating over the hierarchy and e.g. extracting all geometry.

Part of the imported geometry, currently only importing IfcFacetedBrep.

See the following code snippet for the API of iterating over the IFC file.

The one and only codebase

Sun, 25 Jan 2026 13:00:00 +0000

A little while back, my contract ended with Treble Technologies, for whom I had been writing (parts of) a geometry processing pipeline for automated mesh simplification and mesh cleanup in C++.

This was my first real out-of-university job – apart from some freelance work, an internship and my VR startup – and I was ecstatic about the opportunity. I traveled back-and-forth from the Netherlands to Reykjavík, Iceland, and spent all day thinking about geometric problems, reading about data structures and finding novel papers.

VDB - the better octree

Mon, 18 Aug 2025 00:00:00 +0000

I have implemented a voxel data structure similar to an octree, but with a larger branching factor (still powers of 2), that contains a hashmap at the root of the tree. It takes inspiration from the paper “VDB: High-Resolution Sparse Volumes with Dynamic Topology” by Ken Museth.

The image shows the mesh graph voxelized into a tree containing depths 2, 3 and 4 (VDB<2, 3, 4>). Depth 2 gives 64 children, 3 gives 512 children, and 4 gives 4096 children. See the following overview:

Simple undo history for a mesh graph using diffs

Thu, 14 Aug 2025 00:00:00 +0000

Undo is a fundamental feature in many software applications, and my app ShapeReality - 3D Modeling is no exception. Due to the ubiquity of undo, one might expect implementing it to be a solved problem, but there commonly isn’t a one-size-fits-all approach.

This post will go into how I implemented undo for my mesh graph data structure, and how this fits into the complete undo history of an application containing multiple data structures and contexts. These principles should be applicable to other applications and data structures too.

An editable non-manifold polygon mesh data structure

Mon, 28 Jul 2025 00:00:00 +0000

One core data structure in my 3D modeling application is a non-manifold polygon mesh data structure. This data structure is a graph of Vertices, Edges and Faces. It takes inspiration from Blender’s BMesh data structure, the Radial Edge Structure (see Nvidia SMLib - Topology documentation) and the paper Partial Entity Structure: A Compact Boundary Representation for Non-Manifold Geometric Modeling by Lee et al., but arrives at a simpler design that still has the desired feature set.

iOS app launched: 3D modeling on iPhone and iPad

Mon, 28 Jul 2025 00:00:00 +0000

For the past 2 months I have been working on a 3D modeling app for iOS devices using C++ and Swift, and I just released it on iOS.

This release is the product of a self-proposed bet with a friend that I would have to pay him €1000 if I did not launch some application he could install and use within 3 months.

It supports:

Non-manifold polygon meshes with loose vertices and edges (see An editable non-manifold polygon mesh data structure)
Inserting vertices, edges and faces
Extruding edges and faces
Deleting elements
Duplicating elements
Multi element selection
Flipping face normals
Insert primitive shapes
Saving and loading to and from .obj (note that all geometry will be merged into one mesh)
Orbit camera viewport navigation

Timelapse demo of using the app #

metal-experiment: The value of underengineering

Tue, 18 Jun 2024 00:00:00 +0000

Half a year ago I embarked on the quest to build a cross-platform, general purpose game engine. I was working on asynchronous asset loading, a reflection system, an ECS for representing the scene, serialization, a graphics API wrapper for Metal and Vulkan, but barely got some simple rendering tests on top of these systems.

My next steps were to get cross-platform shader compilation working, and to further improve my reflection and serialization implementation.

A quick note about little-endianness

Thu, 23 May 2024 09:00:00 +0000

Little-endian means the least-significant byte is at the smallest address (on the left).

The least-significant byte is the byte that changes the value the least, and is in binary notation on the right:

1
2
3
4
5
6


(binary notation)

 least-significant byte
 │
 ┌──┴───┐
0b0100110110011101

The individual 8 bits that make up the byte are still in the same order. Endianness only is about the order of the bytes.

The ideal XR device and operating system

Mon, 05 Feb 2024 00:00:00 +0000

With the Vision Pro having made its way into the hands of people outside of Apple’s secretive labs, I want to reflect a bit on my conceptions of what an ideal XR device would look like, and to what extent the Apple Vision Pro comes close to this ideal.

Defining success #

I have identified three core use cases an XR device could fulfill:

Provide entertainment
Connect people
Increase productivity

In order for an XR device to be able to become successful, it needs to at least deliver on one of these use cases better than a readily available alternative offering. Note that these alternative offerings can be in different product categories. A pencil and paper still compete with an iPad, regardless of technological innovativeness.

Apple Vision Pro and the importance of tinkering

Wed, 24 Jan 2024 01:00:00 +0000

I am preemptively disappointed by the Apple Vision Pro. Not because it isn’t an absolute marvel of engineering, but because of what its operating system affords the user to do.

For a while I have been reading the book The Innovators by Walter Isaacson, which goes into depth on the history of the personal computer and development of the internet. One thing that was common throughout the majority of the founders of these tech companies was that they grew up tinkering with hardware and later software.

Sunken cost-driven development - Or: why would you ever build a game engine?

Wed, 24 Jan 2024 00:00:00 +0000

A question I get asked a lot is why I decided to build a game engine. All in all, there’s already great commercial engines out there, that, as long as you don’t earn any money, cost nothing.

Unity and Unreal Engine are powerhouses with an abundance of tools and resources built on top of them.

In addition, if commercial engines are not your cup of tea and you wish to go open source, there’s a plethora of options there as well. Godot being the most cited one, but far from the only option.

C++ Game engine - ECS and transform hierarchy

Sat, 20 Jan 2024 00:00:00 +0000

I decided it would be a great idea to implement my own entity component system (ECS). Learned a lot about template metaprogramming in C++ and how to efficiently compute a transform hierarchy with a minimal amount of matrix multiplication using dirty flags and sorting.

Next step: stress test the system with as many instances as possible. And sort the mesh renderers to automatically batch draw calls of objects that contain the same mesh and materials.

C++ Game engine - Texture and mesh import

Tue, 26 Dec 2023 00:00:00 +0000

fully from scratch is not a hill I’m willing to die on, so at least png and gltf import are now done using lodepng and cgltf respectively.

I should probably implement quaternions so that I don’t have to look at this 3D model rotated at 90 degrees any longer.

also, the loading of assets is all hard-coded now. Getting it into production ready scalable state will be the main challenge :)

C++ Game engine - Hello World

Fri, 22 Dec 2023 00:00:00 +0000

This is just a “hello world”, but I did some work to make it cross-platform / platform agnostic.

It uses zero external dependencies, so no SDL, GLFW or GLM, which made it a bit harder.

Next step: import mesh and texture support

It’s tempting to also immediately write a backend for Vulkan and support for Android, but then I’ll never come around building more than a cube :)

My product failed - Reflections on building a VR application

Sun, 03 Sep 2023 00:00:00 +0000

My product failed. But the idea behind it doesn’t die. It’s just its current iteration that does.

The rose-colored start #

After my repeated experience with building prototypes, together with the experience creating AR and VR experiences for the Ministry of Defence, I felt confident enough to try taking the prototype for “XR designer” to the next step. I didn’t want to get stuck at creating software that only “proved a concept”. Because you can’t really prove a concept until you’ve fully sat it out. Similar to how an idea is worth nothing, a prototype isn’t worth that much either and only becomes valuable in the light of it turning into an actual product. Although this depends on your definition of at which level something stops being a prototype.

Rendering in C++ and Vulkan because I outgrew Unity

Fri, 18 Aug 2023 00:00:00 +0000

Over the summer I decided it was time to let go of Unity due to a variety of reasons, so I picked up the famous Game Engine Architecture book, the Vulkan specification and got to work.

This is my first venture into writing code in C++, as opposed to C#, which went as good as you might expect. I abandoned this project after a certain point, because the abstractions I built didn’t make that much sense and I didn’t really know how to progress further.

Spatial user interface demo on Meta Quest Pro

Fri, 07 Jul 2023 00:00:00 +0000

Placing trees in AR in Innovation Space

Fri, 23 Jun 2023 00:00:00 +0000

A 1000 commits later...

Tue, 28 Mar 2023 00:00:00 +0000

Just today I reached the milestone of 1000 commits for the ShapeReality codebase. Because of this, I’m taking the opportunity to reflect on my how I have developed, both on a personal and professional level.

To summarise, I have become a way better programmer, but I still have so many things to learn on a professional level and in terms of domain expertise. Software cannot be created in isolation and requires one to deeply understand the domain of users or clients.

XR Designer - A prototype for an augmented reality design app

Sat, 12 Mar 2022 21:26:27 +0200

The briefing #

In 2018, the Municipality of Eindhoven has created a pact for improving social-economic problems in Woensel-Zuid, one of the city districts of Eindhoven. It focuses on “creating opportunities for children and young people, encouraging entrepreneurship, improving climate resilience and tackling crime and safety related issues.”

In order to reach these goals, getting young people to care about and engage in improving their own neighbourhood was deemed beneficial. So, we were tasked with inspiring this younger demographic through “new methods and technologies such as gamification or digital tools.”

UrbanAR - An Augmented Reality design tool for urban design and planning

Sun, 03 Jan 2021 00:00:00 +0000

See the project page https://urbanar.arjonagelhout.nl/ for more information.

Project Description #

We want to make the urban design and planning process of our cities more fun and engaging: to make our cities more of a collaborative effort and better for everyone. Currently, municipalities are using old methods to get input from citizens, but we can change that!

That’s why we set out to create UrbanAR. An intuitive app in which you can design your dream neighbourhood, a new park or crazy art piece - all right in front of you using augmented reality. The app also allows you to share your ideas with the world! Compete in contests and get inspired by others!

3D Island Generator in Processing

Tue, 01 Oct 2019 00:00:00 +0000

GitHub: https://github.com/ArjoNagelhout/3D_Island_Generator_In_Processing

Memory

Mon, 01 Jan 0001 00:00:00 +0000

App

Settings

You can either use your own sequence, or get a randomly generated sequence.

Use sequence

Sequence

Values must be comma separated. In order to make a number reversed, prefix it with r. Example input:

4, 4, 5, 5, 6, 7, 8, r4, r5, r6, r7, r8

Sequence

Random

Amount

Memory grid

Mon, 01 Jan 0001 00:00:00 +0000

App

Settings

Amount

Timing Time before (in seconds)

Duration visible (in seconds)

Time after (in seconds)