build.gradle

// Gradle script to build Libbulletjme Maven artifacts and desktop native libraries

plugins {
    id 'application'   // to build JVM applications
    id 'checkstyle'    // to analyze Java sourcecode for style violations
    id 'cpp'           // to compile C/C++ code and link native libraries
    id 'java-library'  // to build JVM libraries
    id 'maven-publish' // to publish artifacts to Maven repositories
    id 'signing'       // to sign artifacts for publication
}

// $artifact is set in the gradle.properties file
// or by a -Partifact= option on the command line.

ext {
    groupID = 'com.github.stephengold'
    lbjVersion = '21.3.2'
    baseName = "${artifact}-${lbjVersion}" // for artifacts
    websiteUrl = 'https://github.com/stephengold/Libbulletjme'
}

sourceSets.main.java {
    srcDir 'src/main/java'
    srcDir 'src/main/native' // for IDE access (no Java there)
}
sourceSets.test.java {
    srcDir 'src/test/java'
}

// Generate all JNI header files before compiling any C/C++ code:
tasks.withType(CppCompile) {
    dependsOn('classes', 'compileTestJava')
}

String javaHome = org.gradle.internal.jvm.Jvm.current().javaHome.absolutePath

model {
    buildTypes {
        Debug
        Release
    }

    flavors {
        Dp            // double-precision arithmetic
        DpMt          // double-precision arithmetic, multithreaded
        Sp            // single-precision arithmetic
        SpMt          // single-precision arithmetic, multithreaded
        SpMtQuickprof // single-precision arithmetic, multithreaded, Quickprof profiling
        SpQuickprof   // single-precision arithmetic, Quickprof profiling
    }

    platforms {
        // To build native libraries for Android, use "android.gradle" instead.
        Linux64 {
            architecture 'x86_64'
            operatingSystem 'linux'
        }
        Linux_ARM32hf {
            architecture 'armhf'
            operatingSystem 'linux'
        }
        Linux_ARM64 {
            architecture 'aarch64'
            operatingSystem 'linux'
        }
        MacOSX64 {
            architecture 'x86_64'
            operatingSystem 'osx'
        }
        MacOSX_ARM64 {
            architecture 'arm-v8'
            operatingSystem 'osx'
        }
        Windows64 {
            architecture 'x86_64'
            operatingSystem 'windows'
        }
    }

    toolChains { // prioritize among the native toolchains
        visualCpp(VisualCpp) // used when compiling on Windows
        //clang(Clang) // to prefer Clang over Gcc on Linux

        gcc(Gcc) // default when compiling on Linux
        clang(Clang) // used when compiling on macOS
    }

    components {
        // To build native libraries for Android, use "android.gradle" instead.
        bulletjme(NativeLibrarySpec) {
            targetPlatform 'Linux64'
            targetPlatform 'Linux_ARM32hf'
            targetPlatform 'Linux_ARM64'
            targetPlatform 'MacOSX64'
            targetPlatform 'MacOSX_ARM64'
            targetPlatform 'Windows64'

            sources.cpp.source {
                srcDir 'src/main/native/bullet3'
                srcDir 'src/main/native/glue'
                srcDir 'src/main/native/v-hacd/src'
                include '**/*.cpp'
            }

            binaries.withType(SharedLibraryBinarySpec) {
                String pName = targetPlatform.name
                //println " - $pName  $buildType  $flavor" // to debug this script

                buildable = true
                // Decide whether to build for the target platform:
                if (buildable && project.hasProperty('target')) {
                    // set in gradle.properties file or -Ptarget= on the command line
                    String targetArg = project.ext.target
                    buildable = (pName == targetArg)
                }
                Boolean isDebug = (buildType == buildTypes.Debug)
                Boolean isMt = (flavor == flavors.SpMt || flavor == flavors.SpMtQuickprof || flavor == flavors.DpMt)
                if (project.hasProperty('github')) {
                    // CI build with -Pgithub= specified on the command line
                    String github = project.ext.github
                    if (github == 'debug64') { // skip all except debug/64-bit/non-ARM
                        buildable = isDebug && pName.contains('64') && !pName.contains('_ARM')
                    } else if (github == 'debug64arm') { // skip all except debug/64-bit/ARM
                        buildable = isDebug && pName.contains('64') && pName.contains('_ARM')
                    }
                }

                Boolean isDp = (flavor == flavors.Dp || flavor == flavors.DpMt)
                Boolean isQuickprof = (flavor == flavors.SpMtQuickprof || flavor == flavors.SpQuickprof)
                String os = targetPlatform.operatingSystem.name
                if (buildable) {
                    // Decide whether to build the current flavor:
                    if (project.hasProperty('flavor')) {
                        // -Pflavor= specified on the command line
                        String flavorArg = project.ext.flavor
                        buildable = (flavor.name == flavorArg)
                    } else if (isMt) {
                        // Skip Mt for MacOSX (Xcode does not support OpenMP) and 32-bit targets
                        buildable = (os != 'osx') && pName.contains('64')
                    }
                    //if (isDp) buildable = false // to skip all double-precision flavors
                    //if (isMt) buildable = false // to skip all multithreaded flavors
                    if (isQuickprof) buildable = false // to skip all Quickprof flavors
                }

                // buildtype-specific CPP defines:
                if (isDebug) {
                    cppCompiler.define '_DEBUG'
                    //cppCompiler.define 'BT_ADDITIONAL_DEBUG'
                    //cppCompiler.define 'BT_DEBUG_MEMORY_ALLOCATIONS'
                    //cppCompiler.define 'DEBUG_PERSISTENCY'
                    //cppCompiler.define 'VERBOSE_RESIDUAL_PRINTF'
                }

                // flavor-specific CPP defines:
                if (isDp) {
                    cppCompiler.define 'BT_USE_DOUBLE_PRECISION'
                }
                if (isMt) {
                    cppCompiler.define 'BT_THREADSAFE'
                    cppCompiler.define 'BT_USE_OPENMP'
                }
                if (isQuickprof) {
                    cppCompiler.define 'BT_ENABLE_PROFILE'
                    //cppCompiler.define 'BT_LINUX_REALTIME'
                }

                String q = pName + buildType.name + flavor.name
                if (toolChain in VisualCpp) {
                    cppCompiler.define 'WIN32'
                    cppCompiler.args '/EHsc' // synchronous exceptions only
                    cppCompiler.args "/I$javaHome/include"
                    cppCompiler.args "/I$javaHome/include/win32"
                    cppCompiler.args "/I$projectDir/src/main/native/bullet3"
                    cppCompiler.args "/I$projectDir/src/main/native/bullet3/BulletDynamics/Featherstone"
                    cppCompiler.args "/I$projectDir/src/main/native/bullet3/LinearMath"
                    cppCompiler.args "/I$projectDir/src/main/native/v-hacd/inc"
                    cppCompiler.args "/I$projectDir/src/main/native/v-hacd/public"
                    linker.args 'ws2_32.lib' // for htons()

                    if (isDebug) {
                        cppCompiler.args '/FS' // to serialize PDB-file writes
                        cppCompiler.args '/MTd' // to use LIBCMTD
                        cppCompiler.args '/Zi' // to generate a PDB file containing debug info
                        //cppCompiler.args '/Z7' // to embed debug info in OBJ files
                        linker.args '/DEBUG'
                        if (buildable) {
                            String pdbFile = 'build/libs/bulletjme/shared/'
                            pdbFile += pName + '/debug/'
                            pdbFile += flavor.name + '/bulletjme.pdb'

                            project.tasks.register('copyPdbToDist' + q, Copy) {
                                dependsOn "bulletjme${q}SharedLibrary"
                                from pdbFile
                                rename { String filename ->
                                    return q + '_' + filename
                                }
                                into 'dist'
                            }
                            jar.dependsOn('copyPdbToDist' + q)
                        }
                    } else { // buildType == Release
                        cppCompiler.args '/O2'
                        cppCompiler.args '/Ob3'
                    }
                    if (isMt) {
                        cppCompiler.args '/openmp'
                    }

                } else { // toolChain in Clang or Gcc
                    //cppCompiler.args '-v' // to log compiler details
                    //linker.args '-v' // to log linker details

                    cppCompiler.args '-I', "$javaHome/include"
                    cppCompiler.args '-I', "$projectDir/src/main/native/bullet3"
                    cppCompiler.args '-I', "$projectDir/src/main/native/bullet3/BulletDynamics/Featherstone"
                    cppCompiler.args '-I', "$projectDir/src/main/native/bullet3/LinearMath"
                    cppCompiler.args '-I', "$projectDir/src/main/native/v-hacd/inc"
                    cppCompiler.args '-I', "$projectDir/src/main/native/v-hacd/public"
                    cppCompiler.args '-std=c++11'
                    cppCompiler.args '-Werror=return-type'

                    if (isDebug) {
                        cppCompiler.args '-O0', '-g3'
                    } else { // buildType == Release
                        cppCompiler.args '-O3'
                    }
                    if (isMt) {
                        cppCompiler.args '-fopenmp'
                        linker.args '-lgomp'
                    }

                    if (os == 'osx') {
                        cppCompiler.args '-I', "$javaHome/include/darwin"
                    } else if (os == 'linux') {
                        cppCompiler.args '-I', "$javaHome/include/linux"
                        cppCompiler.args '-fPIC'
                        cppCompiler.args '-fvisibility=hidden'
                        linker.args '-fvisibility=hidden'
                    } else {
                        buildable = false
                    }
                }

                if (buildable) {
                    println 'Build ' + q + ' using ' + toolChain

                    project.tasks.register('copyToDist' + q, Copy) {
                        dependsOn "bulletjme${q}SharedLibrary"
                        from sharedLibraryFile
                        rename { String filename ->
                            return q + '_' + filename
                        }
                        into 'dist'
                    }
                    jar.dependsOn('copyToDist' + q)

                } else { // not buildable
                    //println 'Do not build ' + q // to debug this script
                }
            }

            binaries.withType(StaticLibraryBinarySpec) {
                buildable = false
            }
        }
    }
}

dependencies {
    testImplementation(libs.junit4)
}

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

tasks.withType(JavaCompile).configureEach { // Java compile-time options:
    options.compilerArgs << '-Xdiags:verbose'
    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_20)) {
        // Suppress warnings that source value 8 is obsolete.
        options.compilerArgs << '-Xlint:-options'
    }
    options.compilerArgs << '-Xlint:unchecked'
    options.deprecation = true // to provide detailed deprecation warnings
    options.encoding = 'UTF-8'
    options.headerOutputDirectory = new File('src/main/native/glue')
    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_1_10)) {
        options.release = 8
    }
}

application {
    mainClass = 'jme3utilities.minie.TestApp'
}
tasks.withType(JavaExec).configureEach { // Java runtime options:
    classpath sourceSets.main.runtimeClasspath
    enableAssertions = true
}
run.dependsOn('assemble')
test.dependsOn('assemble')

// Register style-checking tasks:

checkstyle {
    toolVersion = libs.versions.checkstyle.get()
}
tasks.register('checkstyle') {
    dependsOn 'checkstyleMain', 'checkstyleTest'
    description = 'Checks the style of all Java sourcecode.'
}
checkstyleMain.dependsOn('compileTestJava')

// Register publishing tasks:

tasks.register('install') {
    dependsOn 'publishMavenPublicationToMavenLocal'
    description = 'Installs Maven artifacts to the local repository.'
}
assemble.dependsOn('copyToDistJars')
tasks.register('copyToDistJars', Copy) {
    dependsOn 'jar', 'javadocJar', 'signArchives', 'signMavenPublication', 'sourcesJar'
    from 'build/libs'
    include '*.jar', '*.jar.asc'
    into 'dist'
}

jar {
    archiveBaseName = baseName
    doLast {
        println "using Java ${JavaVersion.current()} (${System.getProperty("java.vendor")})"
    }
    manifest {
        attributes 'Created-By': "${JavaVersion.current()} (${System.getProperty("java.vendor")})"
    }
}

java.withJavadocJar()
javadocJar { archiveBaseName = baseName }

tasks.register('sourcesJar', Jar) {
    archiveBaseName = baseName
    archiveClassifier = 'sources'
    description = 'Creates a JAR of Java sourcecode.'
    from 'src/main/java' // default is ".allSource", which includes resources
}

// add javadoc/source jar tasks as artifacts
artifacts {
    archives jar, sourcesJar
}
javadoc.dependsOn('compileTestJava')

assemble.dependsOn('module', 'moduleAsc', 'pom', 'pomAsc')
tasks.register('module', Copy) {
    dependsOn 'generateMetadataFileForMavenPublication'
    description = 'Copies the module metadata to dist.'
    from "${buildDir}/publications/maven/module.json"
    into 'dist'
    rename 'module.json', baseName + '.module'
}
tasks.register('moduleAsc', Copy) {
    dependsOn 'signMavenPublication'
    description = 'Copies the signature of the module metadata to dist.'
    from "${buildDir}/publications/maven/module.json.asc"
    into 'dist'
    rename 'module.json.asc', baseName + '.module.asc'
}
tasks.register('pom', Copy) {
    dependsOn 'generatePomFileForMavenPublication'
    description = 'Copies the Maven POM to dist.'
    from "${buildDir}/publications/maven/pom-default.xml"
    into 'dist'
    rename 'pom-default.xml', baseName + '.pom'
}
tasks.register('pomAsc', Copy) {
    dependsOn 'signMavenPublication'
    description = 'Copies the signature of the Maven POM to dist.'
    from "${buildDir}/publications/maven/pom-default.xml.asc"
    into 'dist'
    rename 'pom-default.xml.asc', baseName + '.pom.asc'
}

publishing {
    publications {
        maven(MavenPublication) {
            artifactId = artifact
            from components.java
            groupId = groupID
            pom {
                description = 'a JNI interface for Bullet Physics and V-HACD'
                developers {
                    developer {
                        email = 'sgold@sonic.net'
                        name = 'Stephen Gold'
                    }
                }
                licenses {
                    license {
                        distribution = 'repo'
                        name = 'New BSD (3-clause) License'
                        url = 'https://opensource.org/licenses/BSD-3-Clause'
                    }
                }
                name = groupID + ':' + artifact
                scm {
                    connection = 'scm:git:git://github.com/stephengold/Libbulletjme.git'
                    developerConnection = 'scm:git:ssh://github.com:stephengold/Libbulletjme.git'
                    url = websiteUrl + '/tree/master'
                }
                url = websiteUrl
            }
            version = lbjVersion
        }
    }
}
publishMavenPublicationToMavenLocal.dependsOn('assemble')
publishMavenPublicationToMavenLocal.doLast {
    println 'installed locally as ' + baseName
}

// Register tasks to sign artifacts for publication:

//   Signing relies on the existence of 3 properties
//   (signing.keyId, signing.password, and signing.secretKeyRingFile)
//   which should be set in the ~/.gradle/gradle.properties file
//   or by -P options on the command line.

signing {
    sign configurations.archives
    sign publishing.publications.maven
}
tasks.withType(Sign).configureEach {
    onlyIf { project.hasProperty('signing.keyId') }
}
signMavenPublication.dependsOn('module')

// Register cleanup tasks:

clean.dependsOn('cleanCxx', 'cleanDist', 'cleanLogs')

tasks.register('cleanCxx', Delete) {
    delete '.cxx'
}
tasks.register('cleanDist', Delete) { // files to be distributed
    delete 'dist'
}
tasks.register('cleanLogs', Delete) { // JVM crash logs
    delete fileTree(dir: '.', include: 'hs_err_pid*.log')
}

// Register javadoc to (web)site tasks, triggered by push-master.yml:

tasks.register('copyJavadocToSite') {
    dependsOn 'copyMasterJavadocToSite'
}
tasks.register('copyMasterJavadocToSite', Copy) {
    dependsOn 'javadoc'
    from "${buildDir}/docs/javadoc"
    into 'build/site/javadoc/master'
}