vulkan-test/flake.nix

{
  description = "C/C++ environment";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs";
    treefmt-nix.url = "github:numtide/treefmt-nix";
    utils.url = "github:numtide/flake-utils";
  };

  outputs = {
    self,
    nixpkgs,
    treefmt-nix,
    utils,
    ...
  }:
    utils.lib.eachDefaultSystem (
      system: let
        pkgs = import nixpkgs {
          inherit system;
          config = {
            allowUnfree = true;
            allowUnsupportedSystem = true;
          };
        };

        stdenv = with pkgs;
          if hostPlatform.isLinux
          then stdenvAdapters.useMoldLinker llvmPackages_18.libcxxStdenv
          else llvmPackages_18.libcxxStdenv;

        sources = import ./_sources/generated.nix {inherit (pkgs) fetchFromGitHub fetchgit fetchurl dockerTools;};

        mkPkg = name: pkgs.${name}.overrideAttrs {inherit (sources.${name}) pname version src;};

        fmt = mkPkg "fmt";

        deps = with pkgs; [
          fmt
          glfw
          glm
          shaderc
          vulkan-extension-layer
          vulkan-memory-allocator
          vulkan-utility-libraries
          vulkan-loader
          vulkan-tools
        ];
      in rec {
        packages = rec {
          graphics-test = stdenv.mkDerivation {
            name = "graphics-test";
            version = "0.1.0";
            src = self;

            nativeBuildInputs = with pkgs; [
              meson
              ninja
              pkg-config
            ];

            buildInputs = deps;

            configurePhase = ''
              meson setup build
            '';

            buildPhase = ''
              meson compile -C build
            '';

            installPhase = ''
              mkdir -p $out/bin
              mv build/graphics-test $out/bin/graphics-test
            '';
          };

          default = graphics-test;
        };

        formatter = with pkgs;
          treefmt-nix.lib.mkWrapper pkgs {
            projectRootFile = "flake.nix";
            programs = {
              alejandra.enable = true;

              clang-format = {
                enable = true;
                package = llvmPackages_18.clang-tools;
              };
            };
          };

        devShell = with pkgs;
          mkShell.override {inherit stdenv;} {
            packages =
              [
                alejandra
                bear
                (llvmPackages_18.clang-tools.override {enableLibcxx = true;})
                lldb
                meson
                nil
                ninja
                nvfetcher
                pkg-config
                unzip

                (writeScriptBin "build" "meson compile -C build")
                (writeScriptBin "clean" "meson setup build --wipe")
                (writeScriptBin "reconfigure" "meson setup build --reconfigure")
                (writeScriptBin "run" "meson compile -C build && build/${packages.default.name}")
              ]
              ++ deps;

            VULKAN_SDK = "${vulkan-headers}";
            VK_LAYER_PATH = "${vulkan-validation-layers}/share/vulkan/explicit_layer.d";
            VK_ICD_FILENAMES =
              if stdenv.isDarwin
              then "${darwin.moltenvk}/share/vulkan/icd.d/MoltenVK_icd.json"
              else let
                vulkanDir = "${mesa.drivers}/share/vulkan/icd.d";
                vulkanFiles = builtins.filter (file: builtins.match ".*\\.json$" file != null) (builtins.attrNames (builtins.readDir vulkanDir));
                vulkanPaths = lib.concatStringsSep ":" (map (file: "${vulkanDir}/${file}") vulkanFiles);
              in "${linuxPackages_latest.nvidia_x11_vulkan_beta}/share/vulkan/icd.d/nvidia_icd.x86_64.json:${vulkanPaths}";

            shellHook = ''
              export PATH="${llvmPackages_18.clang-tools.override {enableLibcxx = true;}}/bin:$PATH"
            '';

            name = "C++";
          };
      }
    );
}