gradle-cmake-plugin

This plugin allows to configure and build using CMake.

Prerequisites

• CMake installed on the system. Download available here.

Apply the plugin

plugins {
    id("com.pixnpunk.gradle-cmake-plugin") version "1.0.0-alpha"
}

Configure the plugin

cmake {
    val buildDir = project.layout.buildDirectory.asFile.get().absolutePath

    // optional configration to path of cmake. Not required if cmake is on the path.
    executable = "/my/path/to/cmake"
    // optional working folder. default is ./build/cmake
    workingFolder = file("$buildDir/cmake")

    ////////////////////
    // cmakeConfigure parameters
    ////////////////////
    // optional source folder. This is where the main CMakeLists.txt file resides. Default is ./src/main/cpp
    sourceFolder = projectDir.resolve("/src/main/cpp")
    // optional install prefix. By default, install prefix is empty.
    installPrefix="${System.getProperties()["user.home"]}"
    // select a generator (optional, otherwise cmake's default generator is used)
    generator = "Visual Studio 17 2022"
    // set a platform for generators that support it (usually Visual Studio)
    platform = "Win32"
    // set a toolset generators that support it (usually only Visual Studio)
    toolset="v141"
    // optionally set to build static libs
    buildStaticLibs=true
    // optionally set to build shared libs
    buildSharedLibs=true
    // define arbitrary CMake parameters. The below adds -Dtest=hello to cmake command line.
    defs = mapOf(
        "test" to "hello"
    )

    ////////////////////
    // cmakeBuild parameters
    ////////////////////
    // optional configuration to build
    buildConfig="Release"
    // optional build target
    buildTarget="install"
    // optional build clean. if set to true, calls cmake --build with --clean-first
    buildClean=false
}

Auto-created tasks

• cmakeConfigure: Calls CMake to generate your build scripts in the folder selected by workingFolder.

• cmakeBuild: Calls CMake --build in the folder selected by workingFolder to actually build.

• cmakeClean: Cleans the workingFolder.

• cmakeGenerators: Try to list the generators available on the current platform by parsing cmake --help's output.

Examples

clean, configure and build:

./gradlew cmakeClean cmakeConfigure cmakeBuild

if you have assembled and clean tasks in your gradle project already you can also use:

assemble.dependsOn cmakeBuild
cmakeBuild.dependsOn cmakeConfigure
clean.dependsOn cmakeClean

and just call

./gradlew clean assemble

If you want to get the output of cmake, add -i to your gradle call, for example:

./gradlew cmakeConfigure -i

Custom tasks

You can create custom tasks the following way:

tasks.register<CMakeConfigureTask>("configureFoo") {
    val buildDir = project.layout.buildDirectory
    sourceFolder=file("$projectDir/src/main/cpp/foo")
    workingFolder = buildDir.dir("/cmake/foo")
// ... other parameters you need, see above, except the ones listed under cmakeBuild Parameters
}

tasks.register<CMakeBuildTask>("buildFoo") {
    val buildDir = project.layout.buildDirectory
    workingFolder = buildDir.dir("/cmake/foo")
// ... other parameters you need, see above, except the ones listed under cmakeBuild Parameters
}

buildFoo.dependsOn(configureFoo) // optional --- make sure its configured when you run the build task

Multiple targets (cross-compilation)

If you need to configure for multiple targets you can use the targets property:

cmake {
  sourceFolder = projectDir.resolve("src")
  buildSharedLibs = true
  buildClean = true
  buildConfig = 'Release'
  targets {
    windows {
      val os = OperatingSystem.WINDOWS
      workingFolder = file(project.getBuildDir(), "cmake${File.separator}${os.nativePrefix}")
      platform= "Win32"
    }
    linux {
      val os = OperatingSystem.LINUX
      workingFolder = file(project.getBuildDir(), "cmake${File.separator}${os.nativePrefix}")
      platform = "x64"
    }
    mac {
      val os = OperatingSystem.MAC_OS
      workingFolder = file(project.getBuildDir(), "cmake${File.separator}${os.nativePrefix}")
      platform = "arm64"
    }
  }
}

Custom tasks using main configuration

As an alternative to using targets you can "import" the settings you've made in the main configuration "cmake" using the 'configureFromProject()' call:

cmake { 
  val buildDir = project.layout.buildDirectory.asFile.get().absolutePath

  executable='/my/path/to/cmake'
  workingFolder = file("$buildDir/cmake")
  sourceFolder = projectDir.resolve("/src/main/cpp")
  installPrefix="${System.getProperties()["user.home"]}"

  generator="Visual Studio 15 2017"
  platform="x64"
}

tasks.register<CMakeConfigureTask>("cmakeConfigureX86") {
    configureFromProject() // uses everything in the cmake { ... } section.

    // overwrite target platform
    platform = "x86"
    // set a different working folder to not collide with default task
    workingFolder=file("$buildDir/cmake_x86")
}

tasks.register<CMakeBuildTask>("cmakeBuildX86") {
    configureFromProject() // uses everything in the cmake { ... } section.
    workingFolder=file("$buildDir/cmake_x86")
}

cmakeBuildX86.dependsOn(cmakeConfigureX86)

License

All these plugins are licensed under the Apache License, Version 2.0 with no warranty (expressed or implied) for any purpose.