How to pull in CMake dependencies

[HerrNamenlos123]

Hi there!
I want to use Chalet for a new project, but I depend on another library of mine, which has modern CMake support.
I already managed to get the library by specifying it as a git dependency and Chalet immediately cloned it. However, how do I now use the library in the build process? I could not find that in the documentation, I know there is CMake integration, but can a third-party dependency automatically be build using CMake, and the rest using Chalet? Or do I have to rewrite the build system in both to be Chalet?

By the way, I don't know all of Chalet's features yet, but if it had CMake integration in both directions, it would be the ultimate winner for me, and I would use it for all projects. I mean if Chalet could automatically consume modern CMake libraries by just specifying the git repo, and if CMake projects could consume Chalet libraries (maybe with a CMake file that calls chalet). Dunno if that's possible, but that would be the ultimate win for me.

[HerrNamenlos123]

Alright I finally managed to compile it. But it's nowhere near perfect. This is my chalet file:

"cppgfx": {
  "kind": "cmakeProject",
  "location": "${external:cppgfx-src}",
  "recheck": true,
  "targets": [
    "cppgfx"
  ]
},
"inversekinematics": {
  "kind": "executable",
  "language": "C++",
  "settings:Cxx": {
    "cppStandard": "c++23",
    "cppModules": true,
    "warningsPreset": "pedantic",
    "includeDirs": [
      "src",
      "${external:cppgfx-src}/include",
      "${externalBuild:cppgfx}/_deps/sfml-src/include",
      "${externalBuild:cppgfx}/_deps/spdlog-src/include",
      "${externalBuild:cppgfx}/_deps/glm-src",
      "${externalBuild:cppgfx}/_deps/imgui-src"
    ],
    "staticLinks": [
      "cppgfx",
      "sfml-audio",
      "sfml-system",
      "sfml-window",
      "sfml-network",
      "sfml-graphics",
      "ImGui-SFML"
    ],
    "libDirs": [
      "${externalBuild:cppgfx}/",
      "${externalBuild:cppgfx}/_deps/sfml-build/lib",
      "${externalBuild:cppgfx}/_deps/imgui-sfml-build",
      "${externalBuild:cppgfx}/_deps/imgui-build",
      "${externalBuild:cppgfx}/_deps/spdlog-build"
    ],
    "defines": [
      "SFML_STATIC"
    ]
  },
  "files": "src/**.cc"
}

It does work, but it feels like a horrible hack to have to do all of this, basically I have to recreate the entire project structure from CMake here, including the structure of ALL transient dependencies. There are surely many more dependencies I am missing, but they are not used yet and don't cause errors.

Also, this is very fragile and will probably break often. Linking dynamically is out of the question at this point, it would blow up complexity x3.

Is there a better way to do this? Can it maybe cmake install the library in a local directory and then use that? This would at least put all DLLs and libs in the same directory, so chalet only needs to care about a single directory...

[rewrking]

That is technically the "old" way you can do it, yes. The second way is to use packages from v0.7.x:

1. This is a very simple way to do it, but in your library, create a json file ("chalet-package.json" or something - the name doesn't matter). add the contents:

{
   "package": {
      "cppgfx": {
         "settings:Cxx": {
            "includeDirs": [
               "src",
               "${external:cppgfx-src}/include",
               "${externalBuild:cppgfx}/_deps/sfml-src/include",
               "${externalBuild:cppgfx}/_deps/spdlog-src/include",
               "${externalBuild:cppgfx}/_deps/glm-src",
               "${externalBuild:cppgfx}/_deps/imgui-src"
            ],
            "staticLinks": [
               "cppgfx",
               "sfml-audio",
               "sfml-system",
               "sfml-window",
               "sfml-network",
               "sfml-graphics",
               "ImGui-SFML"
            ],
            "libDirs": [
               "${externalBuild:cppgfx}/",
               "${externalBuild:cppgfx}/_deps/sfml-build/lib",
               "${externalBuild:cppgfx}/_deps/imgui-sfml-build",
               "${externalBuild:cppgfx}/_deps/imgui-build",
               "${externalBuild:cppgfx}/_deps/spdlog-build"
            ]
         }
      }
   }
}

Then, in your project, add (use the json filename you gave the package):

"packagePaths": [
    "${externalBuild:cppgfx}/chalet-package.json" 
]

in the build target, remove the current includeDirs, staticLinks and libDirs arrays and outside of settings:Cxx, add:

"importPackages": [
   "fmt"
]

I believe that should compile the same way, but ultimately means you only need to import the package and the package path.

More in the docs here

[rewrking]

The next step would be to build cppgfx separately with its own chalet.json. See the open frameworks example project for that kind of project structure:

https://github.com/chalet-org/chalet-example-openframeworks

This is effectively the basis for versioned package management, but I have to put the last few pieces together for that (package repository structure)

[dimitre]

Hello @HerrNamenlos123 I'm pinging here just because with Chalet latest can pass a parameter to use CMake install, like this

targets:
  tess2:
    kind: cmakeProject
    # location: ${external:${name}}
    location: ${external:tess2}
    recheck: false
    rebuild: false
    install: true
    defines:
      - CMAKE_ARCHIVE_OUTPUT_DIRECTORY=lib/${env:PLATFORM}
      - BUILD_SHARED_LIBS=OFF
      - CMAKE_BUILD_TYPE=Release
      - CMAKE_INSTALL_INCLUDEDIR=include
      - CMAKE_INCLUDE_OUTPUT_DIRECTORY=include
    defines[platform:macos]:
      - CMAKE_OSX_ARCHITECTURES=x86_64;arm64
      - CMAKE_OSX_DEPLOYMENT_TARGET=11.5

[HerrNamenlos123]

What would be great in the documentation is a full example on how to use it. Especially in Creating Targets -> CMake Targets, I think there should either be a full example or a link to one, where you show how to use a CMake target. Not only how to declare it but also how to link to it from another target, including libs, libdirs, include directories and defines (all of which would ideally be inferred from CMake automatically).

The example could show a full configuration on how to include a very popular library with modern CMake support, like spdlog, or nlohmann::json, or something similar. That would significantly help to understand the relations between targets.