Upgrade godot-flake to build Godot 4.1 and it's extensions

.gitignore

@@ -0,0 +1,5 @@
+#!/usr/bin/git
+
+## NIX
+# result from `nix build`
+result

custom.nix

@@ -0,0 +1,59 @@
+# custom.nix
+# this modules focuses on generating or overriding the custom.py used to build godot
+{ lib, system, optimize ? "speed", mono ? true, llvm ? true, lto ? true
+, opengl ? true, udev ? true, fontconfig ? true, touch ? false, speechd ? false
+, dbus ? true, pulseaudio ? true, }:
+let
+
+  linux = (system == "x86_64-linux");
+
+  # TODO support override : 
+  override = false;
+  file = "./custom.py";
+
+  # convert parameters to set
+  options = lib.mkIf (override == false) {
+    # optimize is one of "size"or "speed"
+    optimize = optimize;
+    # C# support
+    module_mono_enabled = mono;
+    # llvm
+    use_llvm = llvm;
+    use_lld = llvm;
+    # link time optim
+    use_lto = lto;
+    # add a suffix to binaries
+    extra_suffix = "_flake";
+    # enable openGL3ES renderer
+    opengl3 = opengl;
+    # linux pulseaudio
+    pulseaudio = pulseaudio && linux;
+    # Use D-Bus to handle screensaver and portal desktop settings
+    dbus = dbus && linux;
+    # Use Speech Dispatcher for Text-to-Speech support
+    speechd = speechd && linux;
+    # Use fontconfig for system fonts support
+    fontconfig = fontconfig && linux;
+    # Use udev for gamepad connection callbacks
+    udev = udev && linux;
+    # Enable touch events
+    touch = touch;
+  };
+
+  # convert true/false to "yes" "no" for scons
+  boolToString = cond: if cond then "yes" else "no";
+
+  # turn option set into scons options
+  mkGodotOption = optionSet:
+    (lib.mapAttrsToList (k: v:
+      if (builtins.isBool v) then
+        ("${k}=${boolToString v}")
+      else
+        "${k}=${builtins.toJSON v}") optionSet);
+
+in {
+
+  # we can use (lib.mapAttrsToList (k: v: "${k}=${builtins.toJSON v}") options); if we have values in nix format
+  # resulting scons flag
+  customSconsFlags = (mkGodotOption options);
+}

extensions.nix

@@ -0,0 +1,93 @@
+# extension.nix
+# this modules focuses on building cool extensions for godot
+{ lib, pkgs, system, inputs }:
+with pkgs;
+with builtins;
+let
+  # godot version infos
+  godotVersion = import ./version.nix { inherit system; };
+  # godot custom.py
+  godotCustom = import ./custom.nix { inherit lib system; };
+  # godot build libraries
+  godotLibraries = import ./libs.nix { inherit pkgs; };
+
+  # dependancies
+  nativeBuildInputs = godotLibraries.buildTools ++ godotLibraries.buildDep;
+  buildInputs = godotLibraries.runtimeDep;
+  runtimeDependencies = godotLibraries.runtimeDep;
+
+in rec{
+  #
+  #  Godot-cpp bindings : they are required to
+  #  valid values for target are: ('editor', 'template_release', 'template_debug'
+  #
+  mkGodotCPP =  args @ {target, ...} : stdenv.mkDerivation ({
+      # make name:
+      name = (concatStringsSep "-" ["godot-cpp" target godotVersion.version]);
+      version = godotVersion.version;
+      src = inputs.godot-cpp;
+      # dependancies
+      nativeBuildInputs = godotLibraries.buildTools ++ godotLibraries.buildDep;
+      buildInputs = godotLibraries.runtimeDep;
+      runtimeDependencies = godotLibraries.runtimeDep;
+      # patch
+      patches = [
+        ./patches/godot-cpp.patch       # fix path for g++ 
+      ];
+      # build flags 
+      sconsFlags = [ ("platfom=" + godotVersion.platform) ("target=" + target) "generate_bindings=true"] ++ godotCustom.customSconsFlags;
+      # maybe split outputs ["SConstruct" "binding_generator" ... ]
+      outputs = [ "out" ];
+      installPhase = ''
+      mkdir -p $out
+      cp -r src $out/src
+      cp -r SConstruct $out/
+      cp -r binding_generator.py $out/
+      cp -r gdextension $out/
+      cp -r include $out/
+      cp -r tools $out/
+      cp -r gen $out/
+      chmod 755 $out -R
+      chmod 755 $out/gen/include/godot_cpp/core/ext_wrappers.gen.inc
+      '';
+    } // args);
+
+
+  # function to build any GD-extension
+  buildExt = args @ { extName, version ? "0.1", src, target ? "editor", ... }:
+  let
+    # godot bindings for that extension
+    godotcpp = mkGodotCPP{inherit target;};
+  in
+    stdenv.mkDerivation ({
+      pname = extName + target;
+      version = version;
+      src = src;
+      nativeBuildInputs = nativeBuildInputs ++ [ godotcpp ];
+      buildInputs = buildInputs;
+      runtimeDependencies = runtimeDependencies;
+
+      # patch copies prebuilt godot-cpp
+      # there might be a smarter way to do this, but I'm dumb
+      # use Sconstruct from godotcpp
+      patchPhase = ''
+        mkdir -p godot-cpp
+        cp -r ${godotcpp}/* ./godot-cpp/
+        chmod 777 -R godot-cpp
+        substituteInPlace SConstruct --replace 'env = SConscript("../SConstruct")' 'env = SConscript("godot-cpp/SConstruct")'
+      '';
+
+      sconsFlags = [ ("platfom=" + godotVersion.platform) ("target=" + target) "generate_bindings=true"] ++ godotCustom.customSconsFlags;
+      dontConfigure = true;
+      enableParallelBuilding = true;
+
+      installPhase = ''
+        mkdir -p $out
+        ls -la > $out/files.txt
+        cp -r src $out/src
+        cp -r demo $out/
+        cp -r godot-cpp $out/
+      '';
+      dontFixup = true;
+    } // args);
+}

flake.nix

@@ -1,60 +1,71 @@
+# Godot is a cross-platform open-source game engine written in C++
+#
+# This flake build godot, the cpp bindings and the export templates
+#
 {
-    inputs = {
-        godot.url = "github:godotengine/godot";
-        godot.flake = false;
+  description = "the godot Engine, and the godot-cpp bindings for extensions";
+  inputs = {
+    # the godot Engine
+    godot = {
+      url = "github:godotengine/godot";
+      flake = false;
     };
-    outputs = {self, nixpkgs, ...}@inputs: 
-        let
-            system = "x86_64-linux";
-            pkgs = import nixpkgs{inherit system;};
-        in
-    rec{
-        packages."${system}" = with pkgs; {
-            default = stdenv.mkDerivation rec{
-                name = "godot";
-                src = inputs.godot;
-                nativeBuildInputs = [
-                    scons
-                    pkg-config
-                    vulkan-loader
-                    xorg.libX11
-                    xorg.libXcursor
-                    xorg.libXinerama
-                    xorg.libXrandr
-                    xorg.libXrender
-                    xorg.libXi
-                    xorg.libXext
-                    xorg.libXfixes
-                    udev
-                    systemd
-                    systemd.dev
-                    libpulseaudio
-                    freetype
-                    openssl
-                    alsa-lib
-                    libGLU
-                    zlib
-                    yasm
-                    autoPatchelfHook
-                ];
-                runtimeDependencies = [vulkan-loader libpulseaudio];
-                patchPhase = ''
-                    substituteInPlace platform/linuxbsd/detect.py --replace 'pkg-config xi ' 'pkg-config xi xfixes '
-                '';
-                enableParallelBuilding = true;
-                buildInputs = nativeBuildInputs;
-
-                sconsFlags = "platform=linuxbsd";
-                installPhase = ''
-                    mkdir -p "$out/bin"
-                    cp bin/godot.* $out/bin/godot
-                '';
-            };
-        };
-        devShells."${system}".head = with pkgs; mkShell{
-            nativeBuildInputs = [patchelf nodePackages.http-server];
-            runtimeDependencies = nativeBuildInputs;
-        };
+    # the godot cpp bindings to build GDExtensions
+    godot-cpp = {
+      url = "github:godotengine/godot-cpp";
+      flake = false;
+    };
+  };
+
+  outputs = { self, nixpkgs, ... }@inputs:
+    let
+      # only linux supported
+      # TODO: support darwin and cross compilation
+      system = "x86_64-linux";
+      pkgs = import nixpkgs { inherit system; };
+      lib = pkgs.lib;
+
+      # helper function
+      buildGodot = import ./godot.nix { inherit lib pkgs system inputs; };
+      buildGdExt = import ./extensions.nix { inherit lib pkgs system inputs; };
+
+      # godot engine
+      godot-editor = buildGodot.mkGodot { }; # Godot Editor
+      godot-template-release =
+        buildGodot.mkGodotTemplate { target = "template_release"; };
+      godot-template-debug =
+        buildGodot.mkGodotTemplate { target = "template_debug"; };
+
+      # whole godot package
+      godot-engine = pkgs.buildEnv {
+        name = "godot-engine";
+        paths = [ godot-editor godot-template-release godot-template-debug ];
+      };
+
+      # godot cpp bindings
+      godot-cpp-editor = buildGdExt.mkGodotCPP { target = "editor"; };
+
+      # extension demo
+      godot-cpp-demo = buildGdExt.buildExt {
+        extName = "godot-cpp-demo";
+        src = "${inputs.godot-cpp}/test";
+      };
+
+    in {
+
+      # build functions :
+      lib = { inherit buildGodot buildGdExt; };
 
+      #packages
+      packages."${system}" = with pkgs; {
+        default = pkgs.linkFarmFromDrvs "godot-flake" [
+          godot-engine
+          godot-cpp-editor
+          godot-cpp-demo
+        ];
+      };
+      # dev-shell
+      # TODO : Godot development tools
+      devShells."${system}".default = with pkgs; mkShell { };
     };
 }