Compiler un projet GL4D avec NixOS

NixOS est une distribution Linux unique qui utilise un gestionnaire de paquets déclaratif, ce qui peut rendre la compilation de bibliothèques comme GL4Dummies un peu différente des distributions traditionnelles comme Ubuntu. Dans cet article, je vais partager comment j’ai réussi à configurer et compiler un projet utilisant GL4Dummies sur NixOS.

Le Défi Initial

Sur Ubuntu, installer GL4Dummies est relativement simple grâce à une série de commandes standard :

sudo apt update
sudo apt install -y libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libassimp-dev libfftw3-dev pkg-config automake make autoconf libtool
git clone https://github.com/noalien/GL4Dummies.git
cd GL4Dummies
make -f Makefile.autotools
./configure
make
sudo ldconfig

Cependant, NixOS fonctionne différemment. Au lieu d’installer directement des paquets dans le système, nous devons créer une “dérivation” qui décrit comment construire le logiciel.

Étape 1 : Activer les fonctionnalités expérimentales de Nix

Tout d’abord, j’ai dû activer certaines fonctionnalités expérimentales de Nix. J’ai modifié mon fichier /etc/nixos/configuration.nix :

{ config, pkgs, ... }:
{
  nix.settings = {
    experimental-features = [ "nix-command" "flakes" ];
  };

  # Reste de la configuration...
}

Puis j’ai appliqué la configuration :

sudo nixos-rebuild switch

Étape 2 : Créer une Dérivation pour GL4Dummies

J’ai créé un fichier default.nix pour décrire comment compiler GL4Dummies :

{ lib, stdenv, fetchFromGitHub, pkg-config, SDL2, SDL2_image, SDL2_mixer, SDL2_ttf, assimp, fftw, automake, autoconf, libtool }:

stdenv.mkDerivation rec {
  pname = "gl4dummies";
  version = "master";

  src = fetchFromGitHub {
    owner = "noalien";
    repo = "GL4Dummies";
    rev = "master";
    sha256 = "sha256-FLrqrDO2fQ4DlN3RIvbAw1aEo9pacZGp3z18umJY9p0=";
  };

  nativeBuildInputs = [
    pkg-config
    automake
    autoconf
    libtool
  ];

  buildInputs = [
    SDL2
    SDL2_image
    SDL2_mixer
    SDL2_ttf
    assimp
    fftw
  ];

  configurePhase = ''
    make -f Makefile.autotools
    ./configure --prefix=$out
  '';

  meta = with lib; {
    description = "GL4Dummies library for OpenGL programming";
    homepage = "https://github.com/noalien/GL4Dummies";
    license = licenses.lgpl3;
    platforms = platforms.linux;
  };
}

Étape 3 : Créer un Environnement de Développement

Pour faciliter le développement, j’ai créé un fichier shell.nix qui définit un environnement de développement avec toutes les dépendances nécessaires :

{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  buildInputs = with pkgs; [
    (callPackage ./default.nix {})
    SDL2
    SDL2_image
    SDL2_mixer
    SDL2_ttf
    assimp
    fftw
  ];

  shellHook = ''
    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${pkgs.lib.makeLibraryPath [
      pkgs.SDL2
      pkgs.SDL2_image
      pkgs.SDL2_mixer
      pkgs.SDL2_ttf
      pkgs.assimp
      pkgs.fftw
    ]}"
  '';
}

Étape 4 : Structure du Projet

J’ai organisé mon projet de manière logique :

mon_projet_gl4d/
├── default.nix       # Dérivation GL4Dummies
├── shell.nix         # Environnement de développement
├── src/              # Mon code source
│   └── test.c
└── Makefile          # Pour compiler mon code

Le fichier test.c était un programme simple pour tester GL4Dummies :

#include <GL4D/gl4duw_SDL2.h>

int main(int argc, char ** argv) {
  if(!gl4duwCreateWindow(argc, argv,
                        "Mon Premier Programme GL4D",
                        10, 10, 800, 600,
                        GL4DW_RESIZABLE | GL4DW_SHOWN))
    return 1;

  gl4duwMainLoop();
  return 0;
}

Et le Makefile :

CC = gcc
CFLAGS = -Wall -O2 $(shell pkg-config --cflags gl4dummies)
LDFLAGS = $(shell pkg-config --libs gl4dummies)

TARGET = test
SRCS = src/test.c
OBJS = $(SRCS:.c=.o)

$(TARGET): $(OBJS)
	$(CC) $(OBJS) -o $(TARGET) $(LDFLAGS)

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) $(TARGET)

Étape 5 : Compiler et Exécuter

Pour compiler et exécuter mon programme :

cd mon_projet_gl4d
nix-shell  # Entre dans l'environnement de développement
make       # Compile le programme
./test     # Exécute le programme

Conclusion

Compiler GL4Dummies sur NixOS demande une approche différente, mais offre plusieurs avantages :

1. Isolation : L’environnement de développement est isolé du système.
2. Reproductibilité : La construction est déterministe et reproductible.
3. Dépendances explicites : Toutes les dépendances sont clairement définies.

Prochaine étape Nix Flakes?

Je n’ai pas enccore fait assez de recherche sur les Nix flakes, qui est la nouvelle méthode recommandée mais encore expérimentale.