DEV Community: Tenry

C++ development with Docker + VSCode

Tenry — Sun, 02 Nov 2025 16:55:09 +0000

I recently experimented with C++ development inside Docker containers on my Linux machine. Here's why I use Docker:

Isolated environments with self-contained C++ compilers and libraries
Reproducible builds that can be easily replicated on fresh systems
Easy cleanup of project-related files when they're no longer needed

Docker images

Since I develop C++ projects for various target systems, I created multiple Docker images, each dedicated to a specific target:

cppdev: Essential build tools and programs (gcc, cmake, git, etc.) for native Linux compilation
mingwdev: Essential build tools for cross-compiling to Windows using mingw-w64
devkitpro: Complete devkitPro installation for homebrew development on consoles like the Nintendo DS or Nintendo Switch
n64dev: Development environment for the Nintendo 64 using libdragon

For most images, I differentiate between two tags: "essential" (containing only the compiler and essential programs) and "latest" (which includes commonly used packages like SDL2 pre-installed).

This is my Dockerfile for cppdev:essential:

# docker build -t cppdev:essential .

FROM ubuntu

RUN apt-get update && apt-get install -y --no-install-recommends \
  build-essential \
  ca-certificates \
  cmake \
  curl \
  git \
  nano \
  vim \
  wget \
  && rm -rf /var/lib/apt/lists/*

And this is my Dockerfile for cppdev:latest, based on the image above:

# docker build -t cppdev:latest .

FROM cppdev:essential

RUN apt-get update && apt-get install -y --no-install-recommends \
  libfmt-dev \
  libglm-dev \
  libsdl2-dev \
  && rm -rf /var/lib/apt/lists/*

I follow a similar approach for all other target systems. Some Dockerfiles are more complex when they require downloading, compiling, and installing dependencies from source. Here's my setup for MinGW-W64:

# docker build -t mingwdev:essential .

FROM ubuntu

RUN apt-get update && apt-get install -y --no-install-recommends \
  build-essential \
  ca-certificates \
  cmake \
  curl \
  git \
  mingw-w64 \
  nano \
  vim \
  wget \
  && rm -rf /var/lib/apt/lists/*

# docker build -t mingwdev:latest .

FROM mingwdev:essential

RUN cd /usr/src \
  && git clone https://github.com/libsdl-org/SDL.git \
  && cd SDL \
  && git checkout release-2.32.10 \
  && mkdir /usr/build \
  && cd /usr/build \
  && cmake -DCMAKE_INSTALL_PREFIX=/usr/x86_64-w64-mingw32 -DCMAKE_TOOLCHAIN_FILE=/usr/src/SDL/build-scripts/cmake-toolchain-mingw64-x86_64.cmake /usr/src/SDL \
  && cmake --build . --parallel \
  && cmake --install . \
  && cd / \
  && rm -rf /usr/src/SDL /usr/build

RUN mkdir -p /usr/local/share/cmake/toolchains

COPY MinGW.cmake /usr/local/share/cmake/toolchains/MinGW.cmake

RUN cd /usr/src \
  && git clone https://github.com/g-truc/glm.git \
  && cd glm \
  && git checkout 1.0.2 \
  && mkdir /usr/build \
  && cd /usr/build \
  && cmake -DCMAKE_INSTALL_PREFIX=/usr/x86_64-w64-mingw32 -DCMAKE_TOOLCHAIN_FILE=/usr/local/share/cmake/toolchains/MinGW.cmake \
  -DCMAKE_BUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF /usr/src/glm \
  && cmake --build . --parallel \
  && cmake --install . \
  && cd / \
  && rm -rf /usr/src/glm /usr/build

This is my MinGW.cmake toolchain file I put next to the Dockerfile for the mingwdev:latest image:

set(CMAKE_SYSTEM_NAME Windows)
set(CMAKE_SYSTEM_PROCESSOR x86_64)

set(CMAKE_SYSROOT "/usr/x86_64-w64-mingw32")
set(CMAKE_FIND_ROOT_PATH "${CMAKE_SYSROOT}")
set(CMAKE_INSTALL_PREFIX "${CMAKE_SYSROOT}")

find_program(CMAKE_C_COMPILER NAMES x86_64-w64-mingw32-gcc REQUIRED)
find_program(CMAKE_CXX_COMPILER NAMES x86_64-w64-mingw32-g++ REQUIRED)
find_program(CMAKE_RC_COMPILER NAMES x86_64-w64-mingw32-windres windres REQUIRED)

To configure, build, and install an existing CMake-based project via the CLI, I typically follow these steps:

cd path/to/project
docker run -it --rm --mount type=bind,src="$(pwd)",dsts=/usr/src -w /usr/src mingwdev:latest

# inside docker
mkdir /usr/build
cd $_
cmake -DCMAKE_TOOLCHAIN_FILE=/usr/local/share/cmake/toolchains/MinGW.cmake /usr/src
cmake --build . --parallel
cmake --install .

You may also want to mount a local folder to the build directory inside Docker, or copy the relevant build artifacts to your host system using another method.

Visual Studio Code + dev containers

Visual Studio Code has an extension that enables developing inside a container. In my projects, I typically configure multiple dev containers for different targets.

# .devcontainer/mingwdev-container/Dockerfile

FROM mingwdev:latest

# RUN ... if you want to install certain programs or libraries that are only relevant for this specific project

# The base image happens to provide a user "ubuntu" with UID 1000,
# this happens to be the UID of my local user.
# Do this, if you want to avoid all new files to be owned by root.
USER ubuntu

// .devcontainer/mingwdev-container/devcontainer.json
{
  "name": "MinGW-W64",
  "build": {
    "dockerfile": "Dockerfile"
  },
  "customizations": {
    "bbenoist.Doxygen",
    "GitHub.copilot-chat",
    "GitHub.copilot",
    "ms-vscode.cmake-tools",
    "ms-vscode.cpptools",
    "slevesque.shader",
    "sumneko.lua",
    "xaver.clang-format",
    "ZixuanWang.linkerscript"
  }
}

Note that many VS Code extensions must be installed inside the container—this is what the customizations section handles. Adjust it according to your needs.

Once the dev containers are configured, you can reopen your project in a container (F1 or Ctrl+Shift+P > Dev Containers: Reopen in Container). The first time you reopen the project in a container, it may take a moment to prepare the image.

VSCode C/C++ configuration

One final consideration, especially when targeting multiple platforms: VS Code needs to know about your various configurations (include paths, defines, etc.) for IntelliSense to work properly. To set this up, create a .vscode/c_cpp_properties.json file and add all relevant configurations. For example:

{
  "configurations": [
    {
      "name": "Windows (MinGW-W64)",
      "includePath": [
        "${workspaceFolder}"
      ],
      "defines": [],
      "compilerPath": "/usr/bin/x86_64-w64-mingw32-gcc",
      "cStandard": "c11",
      "cppStandard": "c++17",
      "intelliSenseMode": "windows-gcc-x64"
    }
  ]
}

With multiple configurations, you can switch the active configuration in the bottom-right corner of VS Code when you have a C/C++ file open.

My first experience with Arch Linux

Tenry — Sun, 08 Jun 2025 20:37:55 +0000

Up until recently I have almost only been using Linux Mint as my main computer's operating system. However I was always interested in Arch Linux: full freedom out of the box, up-to-date software from the official repositories. Now it was finally time to upgrade my computer and I took the chance to install Arch Linux.

Test in VirtualBox

Before I started installing it on my computer and getting stucked, I first gave a list of instructions a try in VirtualBox. I installed the base packages and a desktop environment (KDE Plasma) and it was surprisingly easy for me to get everything running. The next step was go apply this to my actual computer.

Ready to install

After my success attempt within VirtualBox, I created a bootable USB stick with the Arch Linux ISO and booted from it. I created a backup of all my valuable data and replaced the hard drive in my computer, so there was nothing important that could accidentally be deleted.

After selecting my USB stick from the boot menu to boot from, I entered the Arch console, where I could start typing commands.

The first thing, I did, is checking internet connection. My computer is connected via a LAN cable - the same as simulated in VirtualBox before - so pinging any domain using the ping command should work. It did not.

I did some research and eventually figured out that "only" DNS resolving was not working. Doing ping 1.1.1.1 or any other specific IP address worked out of the box. I was suggested to check /etc/resolv.conf for an entry for nameserver. There was actually one, pointing to something in the 127.x.x.x space. I replaced it via nano with two other nameserver lines pointing to 1.1.1.1 and 8.8.8.8, tried ping <some-domain> again and now it was working. Phew! Let's make sure NTP for time sync is enabled via timedatectl set-ntp true and continue with the actual installation process.

Disk partitioning

In my case, I have two disks installed in my computer. One HDD, one much smaller but faster SSD. They are identified as /dev/sda and /dev/sdb respectively. I used cgdisk /dev/sda and cgdisk /dev/sdb to partition these. "Partition" basically means to subdivide each drive into smaller so-called partitions so each of them can later be formatted using a specific filesystem and use. For example, one dedicated partition is required for the boot data, I want a dedicated one on the fast SSD for the actual system and two other ones on the slower but larger HDD for my home and personal files.

I formatted my disks like this:

1 GB (SSD) using FAT32 (type EF00) for /boot (/dev/sdb1)
16 GB (SSD) for Swap (type 8200) (/dev/sdb2)
remaining SSD space for system / using ext4 (type 8300) (/dev/sdb3)
Some amount of HDD using ext4 (type 8300) for /home (/dev/sda1)
Remaining amount of HDD using ext4 (type 8300) for /files (here I put almost all of my personal, user-independent files) (/dev/sda2)

After confirming and writing all the partitions, it's time to actual format and mount the partitions.

I used mkfs.fat -F32 /dev/sda1 for the boot / EFI partition (it is required to be FAT32). mkswap /dev/sdb2 for the swap. And mkfs.ext4 /dev/sda1 etc. to format the remaining partitions for using the ext4 filesystem, which is the most common filesystem for Linux system (alongside with the newer btrfs).

After formatting all the disks, it's time to mount them so I can actually access their contents and install data on them:

mount /dev/sdb3 /mnt
mkdir -p /mnt/{boot,home}
mount /dev/sdb1 /mnt/boot
mount /dev/sda1 /mnt/home

For your understanding: everything, that is found in /mnt during the installation progress, will later be the actual root / on the final system (and temporarily during installation when we use arch-chroot in a few minutes).

Installation and configuration

Right now, /mnt is basically empty. There are no programs, no configuration, no anything. The following command installs the Arch Linux base system there:

pacman -K /mnt base base-devel linux linux-firmware linux-headers nano networkmanager amd-ucode

Please note since I have an AMD processor, it's reommended to have amd-ucode for bug and security fixes for my AMD processor. For Intel processors, there would be intel-ucode. On my previous computer (Linux Mint), both of them were installed, but I don't believe you need both of them if you only have either processor.

Next I did some basic straight-forward configuration:

genfstab -U /mnt >> /mnt/etc/fstab
arch-chroot /mnt

ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime
hwclock --systohc

echo "en_US.UTF-8 UTF-8" >> /etc/locale.gen
locale-gen
echo "LANG=en_US.UTF-8" > /etc/locale.conf

# You can choose any name for your computer you like.
echo "arch-linux" > /etc/hostname

cat >> /etc/hosts <<EOF
127.0.0.1 arch-linux
::1       arch-linux
127.0.1.1 arch-linux.localdomain arch-linux
EOF

I do have some specific setup using various groups and additional "users" (when accessing files via the network), but I will mostly skip these as for this article. Essentially, I used the groupadd to create certain groups with specific IDs (since I hade the same IDs on my backup that I'll restore later). The most essential commands to execute for user setup are:

useradd -m -u 1000 -G wheel -s /bin/bash tenry
passwd tenry

And typed my personal password I wanted to use for my account. The membership of the wheel group is used to allow my command to sudo any commands. To make this possible, I had to run EDITOR=nano visudo next and uncomment the line near the bottom mentioning %wheel ALL=(ALL:ALL) ALL.

Bootloader

Next I installed a bootloader, so when the computer starts, that it would find my Arch Linux installation and boots it. I used systemd-boot, for no specific reason. I also know GRUB and there are other options available too.

For installing systemd-boot, I ran the following commands:

bootctl install

cat > /boot/loader/loader.conf <<EOF
default arch
timeout 3
editor 0
EOF

cat > /boot/loader/entries/arch.conf <<EOF
title   Arch Linux
linux   /vmlinuz-linux
initrd  /initramfs-linux.img
options root=PARTUUID=$(blkid -s PARTUUID -o value /dev/sdb3) rw
EOF

Pay special attention to the part mentioning /dev/sdb3. This is where my root partition is located. If it was on a different partition, this has to be adjusted accordingly.

Extras

Now the base system should be ready. But before finishing up and booting into my system, there were certrain extra things I wanted to install (it could also be done afterwards). The system may be fully ready for some people to use from here, if you do not intend to have any GUI, for example, if you are only using this computer as a server. In my case however I wanted a full GUI right when booting into the computer.

First, the network manager should be enabled using systemctl enable NetworkManager.

Next, since I have an Nvidia graphics card in my computer (GeForce GTX 1060, to be specific), I wanted the (proprietary) nvidia drivers to be installed. I did so using pacman -S nvidia nvidia-utils nvidia-settings.

Then I installed certain packages. For the desktop environment, there are many options, available, such as Cinnamon (which I'm used to from Linux Mint), KDE Plasma and more. After my first glance at KDE Plasma in VirtualBox, I wanted to give this a chance and installed it using pacman -S plasma.

When starting the computer, you would usually be in a terminal, where you log into an account and you would then have to manually start the desktop environment (Plasma in my case). I prefer however to have a nice looking login screen. For that, I installed lightdm using pacman -S lightdm lightdm-gtk-greeter plasma.

To tell the computer to start Plasma on user login, I had to put a line into my user account's .xinitrc file:

echo "exec startplasma-wayland" > /home/tenry/.xinitrc
chown tenry:tenry /home/tenry/.xinitrc

Plasma supports the legacy X11 window system (the same I had on Linux Mint) and the modern, to some degree experimental Wayland. By "experimental", I mean that many programs might still have issues with Wayland. If anything, that is important for me, would not work well with Wayland, I can simply use startplasma-x11 instead.

EDIT: Actually, the .xinitrc file does not affect which desktop to start upon login (via a display manager like lightdm). This is only when you use the startx command from the command line. In the case of lightdm, there is a little config icon in the top right where I can choose the desktop environment before logging in.

I also installed additional packages using pacman -S <package1> <package2> ... for my personal needs, some of these are:

terminator for the terminal
firefox for the browser
thunderbird for e-mails
dolphin for file browsing
audacious as the audio player

A few essential programs are still missing, such as a simple image viewer. I will install those later.

Final cleanup and booting issues

Now everything should be ready, so I used the following commands to exit the installation process and reboot the computer:

exit # exiting from arch-chroot
umount -R /mnt
reboot

In the BIOS boot settings, I ensured the order so my SSD, which had the EFI installed, was on the first place, and booted into Arch Linux from that.

I saw some text on the screen, starting to initialize some things, but it hang up very quickly. Luckily, the text on the screen gave me the hint where something is wrong. Essentially it told me something about not being able to find something with PARTUUID=$(blkid -s PARTUUID ....

I restarted my computer and booted from the USB stick again, so I can investigate the installation configuration. Something appeared to be off in /loder/entries/arch.conf on my boot partition. I did have a typo there which I fixed, but I was still not able to boot. It appeared that for some reason my installation would not be able to run $(blkid -s ...), even though the same was working on my VirtualBox test before. Even after typing the blkid command manually, it gave me an actual uuid. I decided to replace replace the inline command with the actual, hardcoded UUID. This is also where I learned there is a UUID and a PARTUUID, and depending on which ID from the blkid command I'm using, it must be either UUID=... or PARTUUID=... in the arch.conf file.

Finally I was able to boot successfully into Arch! But... there was no login screen. Not a graphical one. There was only the terminal asking me for credentials. Looks like lightdm was not starting. Quickly I realized I forgot to execute one more command which I was supposed to execute right after installing lightdm: systemctl enable lightdm. So, in the terminal, I logged into my account, ran this command manually and restarted.

EDIT: It appears that the Plasma installation comes with the "SDDM" login screen, but it was not enabled automatically in my case. If you want to switch from lightdm to SDDM, simply do systemctl disable lightdm && systemctl enable sddm as sudo.

Now I actually had a graphical login screen! Not very beautiful, as the background is fully black, for example, but I'm happy so far! Now, after typing in my credentials to log in, it would actually also start the Plasma desktop interface and basically everything I needed was working! I had internet, I had music, and the nvidia drivers appeared to be working too.

After installation

Of course, minor things were still missing or not configured according to my needs, which I install or configure one after another. For example, LibreOffice was missing, I installed it using pacman -S libreoffice-fresh. My keyboard layout was set to default US, but I prefer "US International" (which allows me to type many more special characters), this I configured in the settings provided to my by Plasma. Japanese characters in browser and mail were missing, so I installed additional fonts and Japanese characters could be displayed on my screen.

Summary

As of writing this article, this is basically my first day of actually using Arch Linux with Plasma, after I have been using Linux Mint with Cinnamon for many, many years. As of now I'm very happy with everything and I'm looking forward gathering more experience with Arch Linux - hopefully mostly positive ones.

Do you have experience with Arch Linux? What do you think about Arch Linux, compared to easier-to-use systems like Ubuntu or Linux Mint? Let me know in the comments!

My personal folder hierarchy

Tenry — Thu, 12 Sep 2024 18:34:22 +0000

On computers, you deal with files and folders. You download something on the internet, it appears in your personal Downloads folder. You copy your favorite photos from your phone to your computer, you put them in your personal Pictures folder. Your favorite music is stored in your personal Music folder. You start working on a new project, you put it in... where do you actually put it? Do you put it into Documents? But it's not a bare document you are creating. Maybe creating a Projects folder? What if you have multiple accounts (e.g. for private and work) on the same computer and want to share files, such as your music, across these? Do you put these into the one account's share folder, the other one?

These are more are questions I often stumbled upon when I started doing more and more on computer, making games, websites, music and more. And across multiple operating systems too (Windows and Linux). In this article I want to give you some insights into how I am managing the files on my computer.

My folder hierarchy

It all started when I had a Linux computer I used for both work and private stuff. At home, I downloaded music I also liked listening to in the office. At home, sometimes I coded some stuff I would like to try in the office. So, I had a bunch of files of my computer I wouldn't strictly consider belonging to either my work or my private account. A new root folder had to be created.

The birth of /files

So, I went sudo and created a root /files directory, making sure my casual accounts have regular reading and writing access to it. I created a few base directories for different purposes. For example, there was /files/dev for all my development stuff, I had another directory for all my "personal" stuff and another one from the stuff from the internet, each once again divided into music, videos etc.

Over time, I noticed my structure wasn't ideal yet. All my programming stuff went into /files/dev, but when I made some music for my game project, I often put it into my personal music folder, since the music project is no coding. I also like casually listening to the music I created myself, but it was separate from all the music from the internet. So recently I revised the structure underneath /files and this is what I came up with:

My folder hierarchy

/files/inbox: Here I put all kind of random stuff I didn't sort into anywhere else yet.

/files/library: This is where I put all kind of resources, music, videos etc. that is not "personal". The resources can be created by myself, such as music I published or Blender templates I created for later use. These files should be "ready to use", so I put my finished MP3 here, not the Cubase project file. Most of the files here however are simply files downloaded from the internet.

I divide this folder into fonts, games, icons, music, pictures, soundfonts, sounds, textures, videos, vst and wallpapers.

/files/personal: This one is very similar to the library folder, having nearly the same structure. The main difference is that this folder contains personal and sensitive files such as private photos, contracts or videos of that party recently where I have not been at.

/files/projects: Finally, there is my projects folder. In the past, when it was still called "dev", I only created game and app projects in here. I repurposed it to also contain music projects, 3D projects and more, since these projects may also require multiple files per project and I work on them over time.

What do you think about this hierarchy? How do you organize your files? Let me know in the comments :)

Bonus: Other devices

Most of my work is done on my Linux computer, having /files in the root. In some cases however I have to work on a Windows computer, for example when using my favorite DAW, which is only available on Windows. However, I still wanted to have all my project files on a central location, which (currently) is my Linux computer. So I started sharing my /files directory on the local network using SMB. That way, I can easily access my Linux files from my Windows computer. I mounted it to a dedicated drive letter F:. So music projects, I do on my Windows computer, go to F:\projects\music and I'll find it on my Linux computer at /files/projects/music.

Comparison of audio formats for games

Tenry — Sun, 31 Oct 2021 19:05:23 +0000

When you want to make games, like I do, you may stumble upon the question which audio format to use. There is MP3, there is MIDI and much more!

This article ist mostly written for developers who create their own engine, such as in C or C++. Existing game engines, such as Unity, Unreal or GameMaker, may be more restricted in which formats you can use and how you can play back the audio.

Audio stream (MP3, WAV etc.)

This category of audio is probably the most well known one. Essentially, these files simply contains a single stream of raw audio data. The audio data may be given for a single (mono) channel, for two (stereo) channels or more. The bit depth may be 8-bit, 16-bit or more. The samplerate may be 44100 Hz, 48000 Hz or something else.

Since raw audio can be quite big in file size, most audio stream formats use some sort of compression, usually lossy by removing frequencies that are (possibly) not heard by the human ear and more compression magic.

The most well known audio formats I know about are:

WAV (.wav)
MP3 (.mp3)
Ogg Vorbis (.ogg)
Ogg Opus (.opus)
FLAC (.flac)

WAV

The WAV format is probably the simplest audio format of all. The format is quite simple and if the audio is not compressed in any way (that's the usual case), you can write a WAV encoder and decoder easily yourself.

C/C++ integration

If you want to use a library for WAV encoding or decoding, I can suggest libsndfile. It also supports many other audio formats.

MP3

MP3 is probably the most known audio type in the world. But it also has the poorest quality of those formats I know. The only benefits of MP3 I can think of are:

smaller file size than WAV and maybe FLAC
everybody knows MP3, anybody can play MP3

But if you are working on your own game engine, you can decide yourself which audio format to choose. So I would strongly suggest to use Vorbis or Opus instead.

C/C++ integration

If you want to decode MP3 files, there are to libraries I can recommend:

libsndfile (also supports many other formats)
LAME

Ogg Vorbis and Opus

For me those two formats are similar, since they are both usually used in an "ogg" container and are both developed by ther Xiph.Org Foundation. Opus appeared after Vorbis and is meant to replace Vorbis.

Both Vorbis and Opus have better audio quality and smaller file size than MP3.

C/C++ integration

For Vorbis and Opus, there are easy to use official libraries.

If you intend to integrate also other audio formats, such as FLAC, MP3 or WAV, I recommend the use of libsndfile, which supports all of these formats with a uniform interface.

FLAC

FLAC stands for Free Lossless Audio Codec. Unlike most other formats, and like WAV, this format provides lossless audio. It uses a good compression algorithm to be smaller than usual WAV files, but it will be bigger than with Vorbis and Opus for example.

C/C++ integration

There is the official library by xiph.org.

If you intend to integrate also other audio formats, such as Opus or WAV, I recommend the use of libsndfile, which supports all of these formats with a uniform interface.

MIDI

This is probably the second well known audio format. Unlike sampled audio streams, like MP3 or WAV, this file format only contains music instructions. You can basically imagine its contents like this:

play note C5 at 3 seconds on channel 1 using instrument 7
stop note on channel 1 at 4 seconds
and so on...

This this format does not include any audio samples, it is also the smallest of all file formats. However, in order to play a MIDI file, you will also need a so called SoundFont, which actually includes the instrument audio data that can be played.

If you have a MIDI file on your machine and play it with an audio player, it may sound different using different audio players or machines, since each player and each system may have a different default sound font they use for audio playback. If you want your MIDI file to sound the same for any player, you should provide your own sound font with your game. Luckily, you only need a single sound font (assuming it contains all instruments you need) and can have hundreds of little MIDI files in your game you can play.

C/C++ integration

For playing MIDI files, I suggest FluidSynth. You can load a sound font into it and then either play back an existing MIDI file or programmatically send MIDI commands to the library.

Module / Tracker music

These file formats are basically a combination of a MIDI file and a sound font (although the technical details are completely different).

A module file contains a list of audio commands to play and all the instrument (audio) data so a standalone module file can be played back. This makes a module file smaller than audio streams, but larger than MIDI files (if you don't count the sound font).

The four best known tracker formats are:

MOD
XM ("extended module" by Triton's FastTracker 2)
S3M (ScreamTracker 3 Module)
IT (Impulse Tracker)

C/C++ integration

If you want to play tracker music, I can recommend libopenmpt, or, if you need more control about the playback and event syncing, BASSMOD.

Multiple layers

If you want to use music in your game, you might want to work with several audio layers and adjusting a layer's volume depending on the area you are in the game. Let's say, you have the same music (tempo, length) for your overworld and underwater, but using different instruments.

If you work with audio streams such as Vorbis or Opus, you will need to have one file per layer and make sure that all layers are started playing exactly synchronously, but all layers except for one being muted. During the gameplay, you can adjust the layers' volumes dynamically.

MIDI and tracker files both work with multiple channels for different instruments. Depending on the options your library has, you can work with a single audio file containing all layers and adjust a channels volume dynamically.

Loops

Audio streams normally do not support loop points. Depending on the music, you may simply loop the whole music and it sounds well. But if you have a music with an intro that shall only be played once, you will need a dedicated solution. The best way to go is to write down the music's loop points somewhere (such as a meta file) and after decoding the last audio sample, instead of jumping back to sample 0 of the file, you jump back to the specified loop point.

MIDI normally also do not have loop points. However, it's possible to add for example "cue" points to a MIDI file. You can remember the cue point's location and jump back to that when the end of music is reached.

Tracker music basically all support loop points. They either include a "restart position" property in the file header or a "jump to" command within the music itself. Tracker libraries will make use of these loop points and you don't need to do anything here.

When your C++ code complains about undefined references

Tenry — Wed, 09 Dec 2020 18:56:41 +0000

Usually, when you compile and link your code and your compiler complains about undefined references, you check which references are missing and usually quickly find out which library you forgot to link.

Today, however, I encountered a strange issue where the compiler complained even though the (static) library, which provides the symbols in question, was clearly added to the command line that links the final binary. So what was going on?

In my specific case, I built the Lua library, and got some files in the end, including some header files like lua.h or lauxlib.h and of course the liblua.a. I wrote some basic code to verify that Lua is actually working. Following some quickstart tutorial on the internet, my C++ code somewhat looked like this:

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

int main(int argc, char **argv) {
  lua_State *L;
  L = luaL_newstate();
  luaopen_base(L);

  luaL_loadstring(L, "(some lua code)");

  // and so on...

  return 0;
}

I put everything in a CMake file, compiled and bam, undefined references. I enabled verbose output to verify it's actually linking the liblua.a file. I verified it's the right location and the file actually exist.

Didn't I compile the Lua library correctly? Were the symbols in question missing? Using nm showed me that the symbols in questions are there:

$ nm liblua.a | grep luaL_loadstring
0000000000002d60 T luaL_loadstring

So, why does it complain? It took like like half an hour to figure out where the issue is.

The solution

The issue is C++. C++ uses name mangling which differs from the generated names in C. Lua is a C library and I compiled it as C. Since I include the C header file lua.h in a C++ file, it's treated as C++ code, hence the compiler is looking for C++ names.

Luckily, Lua also provides a C++ header file, lua.hpp. I replaced my #include <lua.h> by #include <lua.hpp> and et voilà, it works!

What does lua.hpp actually do? Not much:

extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

If you have some experience with coding in C++, you might already have used other C libs, also simply #include <somelib.h>, without having any issues. So, what do others do? Checking the C header file of another lib, the outline looks like this:

#ifdef __cplusplus
extern "C" {
#endif

// all the declarations go here

#ifdef __cplusplus
}
#endif

__cplusplus is only defined if this file is processed as a C++ file. For some reason, the lua.h file does not do that, so that's why they provided a dedicated C++ header file.

How I work with Linux and Windows together

Tenry — Tue, 08 Dec 2020 11:56:30 +0000

I am a hobby programmer who loves to make games, desktop applications and websites. For some task, I use Linux, while for others I use Windows. But how do I manage to work with two different systems and file management? I'll give you an insight into my computer setup.

My main workstation

Personally I love Linux. It's very easy to code for it: apt-get install g++ and you're ready to compile your C++ program. apt-get install terminator and I'm ready to use my favorite terminal.

But I don't only use this computer for programming. Nearly everything else I do on a computer, such as watching videos or chatting with friends, I do here. I can do almost everything I need.

Where Linux only is not sufficient

Unfortunately, there are some things I can't do on my Linux computer or what simply works better on Windows. Some computer games for example. Or some programs for creating games or music such as Unity or Cubase.

For that reason, I bought a second computer only for running Windows. I'm aware of dual-booting. I could simply shut down Linux, switch to Windows and vice versa. But it's too much time consuming, especially, if I only want to quickly test something out.

Two computers, one keyboard

If you think about working with two computers, you might probably imagine also having two keyboards and two mice on your desk, or at least switching the cables every time you want to switch the computer. I don't have this!

On my desk, there's only one keyboard, only one mouse, and I can switch between the two computers instantly. There's a program on the internet that allows me to do so: Synergy. I install that programm on my Linux and on my Windows computer, configure it and tell the Linux instance, that this is my host. This is where my keyboard and mouse is physically connected to.

Now, I simply move with my mouse to the right out of the Linux monitor and it appears on my Windows monitor. All keyboard and mouse input is now redirected to my Windows comptuer. I move my mouse back to the left where my Linux monitor is and all keyboard and mouse input goes back to my host system. It's incredible magic and working really great!

By the way, it also allows me to copy and paste text :)

File sharing

Now that I can seamlessly create my 3D models on Linux and create a Unity game on Windows, or code my game in C++ on Linux and make the music for it in Cubase on Windows, how do I get the files from one computer to the other?

NAS

One thing I tried is a network-attached storage, or NAS for short. It works really fine for moving individual files and folders between my computers and backing up my files on the NAS.

However, when it's about to have whole projects living on the NAS instead on one of the computers, I feel the bottleneck - at least for my NAS. I created a new Unity project on Windows and I selected a folder on the NAS. I immediately noticed how much slower Unity was working if the whole project is living on the (local) network. I couldn't work really well with that, so I need a different solution.

rsync

The next solution, I came up with quite recently, is working with rsync on my Linux computer. First, I chose a folder on my Windows computer to share on the network. On my Linux computer, I can now mount that shared folder by adding a configuration into my fstab file:

//192.168.0.4/share /windows cifs username=share,uid=tenry,gid=tenry,noauto,nofail,exec,dev,suid

My Windows computer is on a specific local IP address, let's say 192.168.0.4 for example. On the Windows share settings, I called the shared folder share, and I want it to be mounted on my Linux computer at /windows in the root.

Now I can easily access the shared Windows files on my Linux computer as if they were actually on my Linux computer.

Unfortunatly, I didn't find a way (yet) to share a whole drive (e.g. C: or D:) on the network, but maybe it's better to not do so. Instead, I created a new folder share where I put nearly everything I create or work with on Windows.

Now, that my Windows share folder is mounted, I can start working with rsync! I created a few shell script that allows me to quickly "push" some files from Linux → Windows or "pull" from Windows → Linux. So, let's say, I have a new project at /path/to/my/project, I simply cd into that directory on Linux, call my push script with no arguments or . for the current directory, and everything in the current folder becomes available as a copy on my Windows computer at share\path\to\my\project. And when I did some work on my Windows computer, I simply call my pull script on Linux.

I might go more into the details of my script in a different articel if you're interested.

It's still not perfect

If I do something on one computer, the files are not immediately available on the other computer. I push and pull manually all the time, and all the files are just copies.

Also, my script does not delete any files I deleted from one of the systems for security reasons (unless I explicitly tell it to do so) and I'm not sure how good rsync is at detecting renames of files and folders.

What I would like the best is if both computers would actually access the very same storage, without any network bottleneck. But I already see two major issues here:

Linux working with an ext filesystem and having everything at /
Windows working with an NTFS filesystem and having something at C:\, D:\ etc.

If you have any tips or tricks for me regarding the file management, I'm happy to know about them! I hope this article well help some of you setting up your own multi-computer systems.

Update (2024): As of today, I share my Linux primary folder, where I put all my projects etc., via SMB, so I can mount it on my Windows computer at "F:". "F:\projects\music" on Windows is now the same as "/files/projects/music" on Linux. Even though it's still working via network, it doesn't appear to be such a bottleneck than it used to be with my NAS before. Perhaps my NAS simply didn't have enough power to be fast enough for that job.

Bash arguments

Tenry — Tue, 08 Dec 2020 10:35:42 +0000

When executing a shell script, you can pass any number of arguments. Let's say, you invoke a bash script like this: ./script.sh "foo bar" baz"
What does the shell script see?

Variables

Command line arguments are visible in the shell script from $0 to $9, where $0 is always the path to the shell script the way it was called:

./script.sh → $0 contains ./script.sh
path/to/script.sh → $0 contains path/to/script.sh

In other words, this is the path to the script relative to the working directory or an absolute path.

In the example in the introduction of this article, $1 would contain foo bar and $2 baz.

The special variable $@ contains all arguments passed to the script, excluding $0.

Passing arguments to another script

Let's say, we have script1.sh, which calls script2.sh and passes all arguments over. In script1.sh, you pass $@ to script2.sh. But note there's a significant difference if the argument is quoted or not:

If you do ./script1.sh "foo bar" baz and that script does ./script2.sh $@, it would be substituted to ./script2.sh foo bar baz. While we originally only passed 2 arguments to script1.sh, script2.sh would receive 3 arguments.

If the first script would instead quote the argument, ./script2.sh "$@", it would be substituted to ./script2.sh "foo bar" baz.

Looping over arguments

The following example shows how to loop over all arguments passed to a shell script:

#!/usr/bin/env bash

for arg in "$@"
do
  if [ "$arg" == "--help" ] || [ "$arg" == "-h" ]
  then
    echo "Help argument detected."
  fi
done

Terminal colors in C/C++

Tenry — Mon, 07 Dec 2020 10:44:32 +0000

When developing cross-platform terminal applications or using terminal output for logging or debugging, it's useful to color the output in order to not lose the overview.

This article shows how to color the terminal output on various platforms.

Linux

On Linux, you can change the current foreground and background color by writing special character sequences into the output. Write the ESC escape character (octal "\033", hex \x1b), followed by an opening square bracket [. The color definition will follow next, termniated by a lowercase m.

The color definition is a series of numbers, separated by semicolons. In order to make the text color red (number 31), you can write "\033[31m" which will make any following output red. If you want yellow text (33) on blue background (44), you write "\033[31;44m". To reset everything back to the default colors, you write "\033[0m".

#include <stdio.h>

void main() {
  printf("\033[31mred text\n");
  printf("\033[33;44myellow on blue\n");
  printf("\033[0mdefault colors\n");
}

The terminal-colors.d manual gives you an overview over the available codes.

Windows

On Windows, coloring the terminal output, works a bit different. Instead of writing special character sequences into the output, you have to call special functions from the windows library. #include <windows.h> in order to access the Windows functions. This provides the SetConsoleTextAttribute() function that can be used to color the text. You also need to get a handle to the stdout console using GetStdHandle(STD_OUTPUT_HANDLE).

The following code shows how to color the text red and yellow on blue background:

#include <stdio.h>
#include <windows.h>

void main() {
  HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);

  SetConsoleTextAttribute(hConsole,
    FOREGROUND_RED);
  printf("red text\n");

  SetConsoleTextAttribute(hConsole,
    FOREGROUND_RED | FOREGROUND_GREEN | BACKGROUND_BLUE);
  printf("yellow on blue\n");
}

Unlike Linux, where each foreground and background color has an individual number, you work with the red, green and blue channels on Windows. As you can see with yellow, it's a combination of red and green for example.

You can check available color values here.

Predefined C/C++ macros for cross-platform development

Tenry — Sun, 06 Dec 2020 19:10:09 +0000

I do a lot of cross platform development in C/C++, targeting Linux, Windows, macOS, using GCC, MSVC, clang etc.

In order to have cross platform support, it is sometimes needed to add platform dependent or compiler dependent code. I compiled a list of the most important macros I use. This might be helpful for some others as well.

Macro	Definition
`__linux__`	Linux and Linux-derived
`__ANDROID__`	Android
`#if defined(__linux__) && !defined(__ANDROID__)`	Linux (non-Android)
`__APPLE__`	Darwin (macOS and iOS)
`_WIN32`	Windows (32- and 64-bit)
`_WIN64`	Windows 64-bit
`_MSC_VER`	Visual Studio
`__GNUC__`	gcc
`__clang__`	clang
`__EMSCRIPTEN__`	emscripten
`__MINGW32__`	MinGW 32, MinGW-w64 32-bit
`__MINGW64__`	MinGW-w64 64-bit
`ARM9` (1)	Nintendo DS (ARM9)
`__NDS__` (1)	Nintendo DS
`__3DS__` (1)	Nintendo 3DS
`_3DS` (deprecated) (1)	Nintendo 3DS
`__SWITCH__` (1)	Nintendo Switch
`N64` (2)	Nintendo 64

(1) These are defined by the makefiles provided by devkitpro using the -D option, they are not built into the compilers.
(2) Defined by the makefiles provided by libdragon using the -D option, they are not built into the compilers.

How I started coding

Tenry — Sun, 06 Dec 2020 12:44:06 +0000

Why did I start coding, how did I get there and what am I doing today? In this article, I'll give you a little insight about how I got there where I am.

My childhood

I always loved to "create" my own things. In my childhood, I enjoyed drawing, I had a lot of fun building stuff with LEGO and played with other toys. My family is a bunch of gamers. I grew up playing a lot of Nintendo 64, and also some SNES or Game Boy. What I created on paper or LEGO was often inspired by my favorite games. I'd like to create my own games.

The PC era

When I was around 12 years old when I started using the Windows XP PC from my father. I enjoyed creating formatted RTF documents and drawing in paint. Writing down ideas for games or taking notes about my favorite games, such as character stats or cheat codes.

Eventually, when searching for ways about how to create own games, I found Game Editor and Game Maker. Since our computer also had Ubuntu as a secondary OS installed, I was sometimes on Linux and sometimes on Windows. On Linux, I used Game Editor, since Game Maker was only available for Windows. When I was on Windows, I preferred Game Maker.

During this time, I discovered many other technologies. I got familiar with HTML, PHP and MySQL. Also, I found a very interesting programming language which many game developers seem to use: C++.

There was a German website teaching everything about C++. How to compile code, what are data types, functions, parameters, return values, classes, how to write something into the console and more. I believe almost everything I know about coding I learned from that single website.

I wrote some simple terminal programs, such as a "guess the number" game. Unfortunately, it took quite a while until I found out how to actually create a window and draw on it. Everything the C/C++ standard libraries provided were related to the terminal, files or data structures.

One day, it suddenly became clear to me: there is a so called "library" that allows you for playing music. The download contains .h header files, but there was also a .lib file. Somehow I managed to "link" that lib file into my project, call functions as described in the lib's documentation and compile. And there it was! I had a console window actually playing back some music! Now I thought I know everything I need! Find another library for creating a window and drawing on it, and finally you can really create anything you want!

So my first graphics library I found was Allegro. It allowed me for creating a window, draw something on the screen and do something on user input. I created my own Pac-Man clone this way and it's still enjoyable to play.

More C++ stuff

I believe I used Allegro only for that single project only. I discovered SDL soon (it was still version 1) and I started quite a lot games I wanted to make. One of my projects even had more than 10 complete restarts from scratch. I was always unhappy with some aspect of the coding or I had an idea how it should work even better.

In the middle, I also found SFML as an alternative for SDL and did some stuff on that, just to switch back to SDL later again.

Web development

Independent of my game development experiences, I also started on web development. I originally started coding with PHP and MySQL. In the beginning I didn't use any kind of frameworks at all.

I was around 20 when I learned about JavaScript during apprenticeship. The most confusing aspects about that language for me were callback functions / closures plus them using variables from the outer scope. But, it didn't take long until I started to learn that language really much!

node.js got my attention, I found an alternative to PHP for coding the backend of a website. I started to create a few projects based on node.js. Later, there appeared TypeScript which allows for types and interfaces. I love the impressive and exact code completion available in editors like Visual Studio Code when working with TypeScript, while missing that accuracy in JavaScript.

Electron, a framework that allows for creating desktop applications using web technology appeared into my life. I was wondering: should I stick to C++ for game development or shall I switch to Electron?

C++ vs. Electron

I started coding applications as well as games in Electron + TypeScript. Some of the best points of game development in this combination in my eyes are

easy to code
awesome debugger
finished program can be distributed to Windows, Linux, macOS and even the web out of the box!

But, C++ also has some benefits to offer:

smaller binaries
more control over everything
if done right, better performance

So, I was struggling what to actually use for my game development. The story is not over yet.

Where are my games?

I created a few games in Game Editor, Game Maker and C++. Many of them are really small, based on existing graphics and sounds, and most of them aren't even nearly finished. I'm not particularly proud on any of those old projects, so I don't really advertise them.

There are a few ideas for different games I want to develop and I'm eager to get those games that way I imagine them. I hope, soon one and another of those will eventually become finished and shared with the world. Having people all over the world playing games I've been imaginating since childhood might be my greatest dream.

Thank you very much for reading! Feel free to leave comments below :)