build.gradle

// Gradle script to build jolt-jni 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++ 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
    alias(libs.plugins.analyze) // to catch undeclared/unused dependencies
    alias(libs.plugins.download) // to retrieve files from URLs
}

ext {
    group = 'com.github.stephengold'
    version = '0.5.1-SNAPSHOT'
    baseName = "${artifact}-${version}" // for artifacts
    websiteUrl = 'https://github.com/stephengold/jolt-jni'
}

// Regenerate all JNI header files and unpack Jolt before compiling any C++ code.
tasks.withType(CppCompile) {
    dependsOn('classes', 'compileTestJava', 'unpackJoltSource')
}

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

model {
    buildTypes {
        Debug
        Release
    }

    flavors {
        Dp   // double-precision arithmetic
        Sp   // single-precision arithmetic
    }

    platforms {
        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
        gcc(Gcc) // used when compiling on Linux
        clang(Clang) // used when compiling on macOS

        gcc10Arm(Gcc) { // used at Travis CI and GitHub Actions
            target('Linux_ARM64') {
                cppCompiler.executable = 'aarch64-linux-gnu-g++-10'
                linker.executable = 'aarch64-linux-gnu-g++-10'
            }
        }
        gcc9Arm(Gcc) { // used at Travis CI and GitHub Actions
            target('Linux_ARM32hf') {
                cppCompiler.executable = 'arm-linux-gnueabihf-g++-9'
                linker.executable = 'arm-linux-gnueabihf-g++-9'
            }
        }
    }

    components {
        joltjni(NativeLibrarySpec) {
            targetPlatform 'Linux64'
            targetPlatform 'Linux_ARM32hf'
            targetPlatform 'Linux_ARM64'
            targetPlatform 'MacOSX64'
            targetPlatform 'MacOSX_ARM64'
            targetPlatform 'Windows64'

            sources.cpp.source {
                srcDir 'src/main/native/Jolt'
                srcDir 'src/main/native/glue'
                include '**/*.cpp'
            }

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

                buildable = true
                String os = targetPlatform.operatingSystem.name
                if (buildable && project.hasProperty('bt')) {
                    // set in gradle.properties file or -Pbt= on the command line
                    String btArg = project.ext.bt
                    buildable = (buildType.name == btArg)
                }
                if (buildable && project.hasProperty('flavor')) {
                    // set in gradle.properties file or -Pflavor= on the command line
                    String flavorArg = project.ext.flavor
                    buildable = (flavor.name == flavorArg)
                }
                if (buildable && project.hasProperty('target')) {
                    // set in gradle.properties file or -Ptarget= on the command line
                    String targetArg = project.ext.target
                    buildable = (pName == targetArg)
                }

                // flavor-specific CPP defines:
                Boolean isDebug = (buildType == buildTypes.Debug)
                if (isDebug) {
                    cppCompiler.define '_DEBUG'
                    cppCompiler.define 'JPH_ENABLE_ASSERTS'
                }
                Boolean isDp = (flavor == flavors.Dp)
                if (isDp) {
                    cppCompiler.define 'JPH_DOUBLE_PRECISION'
                }

                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"
                    cppCompiler.args '/std:c++17'

                    if (isDebug) {
                        cppCompiler.args '/MTd' // to use LIBCMTD
                        linker.args '/DEBUG'
                    } else { // buildType == Release
                        cppCompiler.args '/O2'
                        cppCompiler.args '/Ob3'
                    }

                } 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"
                    cppCompiler.args '-std=c++17'
                    cppCompiler.args '-Werror=return-type'

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

                    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

                    String replaceWith = targetPlatform.operatingSystem.name \
                        + '/' + targetPlatform.architecture.name \
                        + '/com/github/stephengold/$1'
                    project.tasks.register('nativesJar' + q, Jar) {
                        archiveBaseName = project.ext.baseName
                        archiveClassifier = buildType.name + flavor.name
                        dependsOn "joltjni${q}SharedLibrary"
                        description "Creates a JAR of the ${q} native library."
                        from sharedLibraryFile
                        rename '(.+)', replaceWith
                    }

                    Task njTask = project.tasks.named('nativesJar' + q, Jar).get()
                    project.artifacts {
                        archives njTask.archiveFile
                    }
                    project.publishing.publications.maven {
                        artifact njTask
                    }

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

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

dependencies {
    testImplementation(libs.jsnaploader)
    testImplementation(libs.junit4)
}

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

tasks.withType(JavaCompile) { // Java compile-time options:
    options.compilerArgs << '-Xdiags:verbose'
    options.compilerArgs << '-Xlint:unchecked'
    options.deprecation = true // to provide detailed deprecation warnings
    options.encoding = 'UTF-8'
    options.headerOutputDirectory = new File('src/main/native/auto')
    options.release = 11
}

application {
    mainClass = 'testjoltjni.app.HelloWorld'
}
tasks.register('ConvexVsMeshScene', JavaExec) {
    mainClass = 'testjoltjni.app.ConvexVsMeshScene'
}
tasks.register('HelloWorld', JavaExec) {
    mainClass = 'testjoltjni.app.HelloWorld'
}
tasks.withType(JavaExec).configureEach { // Java runtime options:
    classpath sourceSets.test.runtimeClasspath
    enableAssertions true
}
run.dependsOn('assemble')
test.dependsOn('assemble')

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

// Register publishing tasks:

tasks.register('install') {
    dependsOn 'publishMavenPublicationToMavenLocal'
    description 'Installs Maven artifacts to the local repository.'
}
tasks.register('release') {
    dependsOn 'publishMavenPublicationToOSSRHRepository'
    description 'Stages Maven artifacts to Sonatype OSSRH.'
}

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

javadoc.dependsOn('compileTestJava')
java.withJavadocJar()
javadocJar { archiveBaseName = project.ext.baseName }

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

publishing {
    publications {
        maven(MavenPublication) {
            artifact sourcesJar
            artifactId artifact
            from components.java
            groupId project.ext.group
            pom {
                description = 'a JNI interface to Jolt Physics'
                developers {
                    developer {
                        email = 'sgold@sonic.net'
                        name = 'Stephen Gold'
                    }
                }
                inceptionYear = '2024'
                licenses {
                    license {
                        distribution = 'repo'
                        name = 'MIT License'
                        url = 'https://opensource.org/licenses/MIT'
                    }
                }
                name = project.ext.group + ':' + artifact
                scm {
                    connection = 'scm:git:git://github.com/stephengold/jolt-jni.git'
                    developerConnection = 'scm:git:ssh://github.com:stephengold/jolt-jni.git'
                    url = project.ext.websiteUrl + '/tree/master'
                }
                url = project.ext.websiteUrl
            }
            version project.ext.version
        }
    }

    // Staging to OSSRH relies on the existence of 2 properties
    // (ossrhUsername and ossrhPassword)
    // which should be stored in ~/.gradle/gradle.properties
    // or passed in the command line

    repositories {
        maven {
            credentials {
                username = project.hasProperty('ossrhUsername') ? ossrhUsername : 'Unknown user'
                password = project.hasProperty('ossrhPassword') ? ossrhPassword : 'Unknown password'
            }
            name = 'OSSRH'
            url = 'https://s01.oss.sonatype.org/service/local/staging/deploy/maven2'
        }
    }
}
publishMavenPublicationToMavenLocal.dependsOn('assemble')
publishMavenPublicationToMavenLocal.doLast {
    println 'installed locally as ' + project.ext.baseName
}

// Register signing tasks:

// Signing relies on the existence of 2 properties
// (signingKeyEncoded and signingPassword)
// which should be stored in ~/.gradle/gradle.properties
// or passed in the command line

signing {
    def signingKey = base64Decode(findProperty('signingKeyEncoded'))
    def signingPassword = findProperty('signingPassword')
    useInMemoryPgpKeys(signingKey, signingPassword)

    sign configurations.archives
    sign publishing.publications.maven
}
tasks.withType(Sign) {
    onlyIf { project.hasProperty('signingKeyEncoded') }
}

def base64Decode(encodedString){
    if (encodedString != null) {
        byte[] decoded = encodedString.decodeBase64()
        String decode = new String(decoded)
        return decode
    }
    return null;
}

// Download and extract archived JoltPhysics source code

tasks.register('downloadJoltSource', Download) {
    src 'https://github.com/jrouwe/JoltPhysics/archive/refs/tags/v5.1.0.zip'
    dest file('downloads/JoltPhysics-5.1.0.zip')
    overwrite false
}
tasks.register('unpackJoltSource', Copy) {
    dependsOn 'downloadJoltSource'
    from (zipTree('downloads/JoltPhysics-5.1.0.zip')) {
        include 'JoltPhysics-5.1.0/Jolt/**'
        eachFile { fcd ->
            fcd.relativePath = new RelativePath(true, fcd.relativePath.segments.drop(2))
        }
        includeEmptyDirs = false
    }
    into layout.projectDirectory.dir('src/main/native/Jolt')
}

// Register cleanup tasks:

clean.dependsOn('cleanAutoHeaders', 'cleanLogs')

tasks.register('cleanAutoHeaders', Delete) { // auto-generated JNI headers
    delete 'src/main/native/auto'
}
tasks.register('cleanDownloads', Delete) { // downloaded files
    delete 'downloads'
}
tasks.register('cleanJoltSource', Delete) { // unpacked Jolt Physics source code
    delete 'src/main/native/Jolt'
}
tasks.register('cleanLogs', Delete) { // JVM crash logs
    delete fileTree(dir: '.', include: 'hs_err_pid*.log')
}