build.gradle

plugins {
    id 'java-library'
    id "maven-publish"
}

def ported = [
        "clean-generated",
        "clean-generated-native",
        "clean-java",
        "clean-native",
        "clean",
        "-copylwjgljars",
        "-copymaventdist",
        "-copymavenpoms",
        "-createmavennativejars",
        "-createmavensourcejars",
        "-createmavenjavadocs",
        "maven",
        "maven-full",
        "-createjars",
        "-createdebugjars",
        "compile_native",
        "compile",
        "-initialize",
        "generate-all",
        "generate-openal",
        "generate-openal-debug",
        "generate-debug",
        "generate-opengl",
        "generate-opengl-debug",
        "generate-opengl-capabilities",
        "generate-opengl-capabilities-debug",
        "generate-opengl-references",
        "generate-opengles",
        "generate-opengles-debug",
        "generate-opengles-capabilities",
        "generate-opengles-capabilities-debug",
        "generate-opencl",
        "generate-opencl-debug",
        "generate-opencl-capabilities",
        "generate-opencl-capabilities-debug",
        "generators",
        "compile_native_es",
        "all",
        "jars",
        "jars_es",
        "jars_NoDEP",
        "touch-version",
        "-distribution_javadoc",
        "-distribution_source",
        "-distribute"
]

def ENV = System.getenv()

ant.importBuild('build.xml') { String oldTargetName ->
    if (ported.contains(oldTargetName)) return oldTargetName
    return "a-" + oldTargetName
}

apply from:"gradle/props.gradle"

def proparties = project.praps

static String getArch(String arch) {
    if (arch == "amd64" || arch == "x64" || arch == "x86_64") {
        return "amd64"
    } else if (arch == "x86" || arch == "i386") {
        return "i386"
    } else if (arch == "armhf" || arch == "armv7") {
        return "armhf"
    } else if (arch == "arm64" || arch == "aarch64" || arch == "armv8") {
        return "aarch64"
    } else if (arch == "ppc64el" || arch == "ppc64le") {
        return "ppc64el"
    } else if (arch == "riscv64") {
        return "riscv64"
    } else if (arch == "armel") {
        return "armel"
    } else if (arch == "powerpc" || arch == "ppc") {
        return "powerpc"
    } else if (arch == "ppc64" || arch == "powerpc64") {
        return "ppc64"
    }

    return "unknown"
}

static String getNativeFolder(Project project, String name, String fold) {
    project.file("lwjgl-platform/src/" + name + "/c/" + fold).mkdirs()
    return project.file("lwjgl-platform/src/" + name + "/c/" + fold).toString()
}

apply from:"gradle/compile.gradle"
apply from:"gradle/clean.gradle"

tasks.register("touch-version") {
    dependsOn ":lwjgl:compileJava"

    doFirst {
        for (final def a in [
                "windows/org_lwjgl_opengl_Display.c",
                "linux/org_lwjgl_opengl_Display.c",
                "macosx/org_lwjgl_opengl_Display.m"
        ]) {
            file("lwjgl-platform/src/${a.split("/")[0]}/c/" + a).createNewFile()
        }
    }
}

tasks.named("a-version-mismatch").get().dependsOn "touch-version"

//tasks.register("compile") {
//    description = "Compiles the java source code"
//    dependsOn "compile_test", "compile_examples"
//}
//
//tasks.register("all") {
//    description = "Creates the Java archives and the natives for the current platform"
//    dependsOn "jars", "compile_native"
//}
//
//// Create ONLY the jar archives
//tasks.register("jars") {
//    description = "Creates the Java archives ONLY and places them in libs/"
//    dependsOn "-initialize", "generate-all", "compile", "-createjars", "-jars_NoDEP"
//}
//
//// Create ONLY the jar archives for the ES build
//tasks.register("jars_es") {
//    description = "Creates the Java archives ONLY for the ES build and places them in libs/"
//    dependsOn "-initialize", "generate-all", "compile", "-createjars_es", "-jars_NoDEP"
//}
//
//tasks.register("-jars_NoDEP", Copy) {
//    from(proparties["lwjgl.temp"].toString() + "/jar") {
//        include "*.jar"
//    }
//
//    into("libs/")
//}
//
//tasks.register("-distribution_javadoc", Zip) {
//    description = "Creates a versioned distribution of javadocs"
//
//    destinationDirectory.set(proparties["lwjgl.dist"])
//
//    from(proparties["lwjgl.docs"]) {
//        include "javadoc/**"
//    }
//    archiveFileName = "lwjgl-docs-" + proparties["lwjgl.version"] + ".zip"
//}
//
//tasks.register("-distribution_source", Zip) {
//    description = "Creates a versioned distribution of the source code"
//
//    destinationDirectory.set(proparties["lwjgl.dist"])
//    archiveFileName = "lwjgl-source-" + proparties["lwjgl.version"] + ".zip"
//
//    from proparties["lwjgl.source.fileset"]
//}
//
//tasks.register("-distribute") {
//    description = "Distributes files"
//    dependsOn "-distribute_base"
//}
//
//tasks.register("-distribute_del", Delete) {
//    delete(fileTree(proparties["lwjgl.temp"].toString() + "/native") {
//        include "**/*"
//    })
//}
//
//tasks.register("-distribute_jar", Copy) {
//    destinationDir = file(proparties["lwjgl.temp"].toString() + "/jar")
//
//    from(proparties["lwjgl.lib"]) {
//        include "*.jar"
//    }
//}
//
//tasks.register("-distribute_base", Zip) {
//    destinationDirectory.set(proparties["lwjgl.dist"])
//    archiveFileName = "lwjgl-" + proparties["lwjgl.version"] + ".zip"
//
//    from(proparties["lwjgl.temp"]) {
//        include "**/lwjgl-" + proparties["lwjgl.version"] + "*/**"
//        with proparties["lwjgl_base"]
//    }
//}
//
//for (final def os in ["windows", "linux", "freebsd", "openbsd", "macosx", "solaris"]) {
//    tasks.register("-distribute_${os}", Copy) {
//        dependsOn "-distribute_del"
//        destinationDir = file(proparties["lwjgl.temp"].toString() + "/native/${os}")
//
//        from proparties["lwjgl.bin"].toString() + "/${os}"
//        with proparties["lwjgl-${os}.fileset"]
//    }
//
//    tasks.named("-distribute").get().dependsOn "-distribute_${os}"
//    tasks.named("-distribute_base").get().dependsOn "-distribute_${os}"
//}

apply from:"gradle/windows.gradle"
apply from:"gradle/macosx.gradle"
apply from:"gradle/linux.gradle"

allprojects {
    repositories {
        mavenCentral()
    }

    tasks.all {
        if (it instanceof JavaCompile) {
            targetCompatibility = JavaVersion.VERSION_1_8
            sourceCompatibility = JavaVersion.VERSION_1_8
            it.options.encoding = "UTF-8"
//            if (JavaVersion.current().isJava9Compatible()) {
//                it.options.release = 8
//            }
//            it.options.compilerArgs += [
//                    "--add-exports",
//                    "java.desktop/com.sun.media.sound=ALL-UNNAMED"
//            ]
        }
    }
}

subprojects {
    version = rootProject.version
    group = rootProject.group
}

publishing {
    publications {
        maven(MavenPublication) {
            artifactId "parent"

            pom {
                name = "Lighweight Java Game Library"
                description = "Lighweight Java Game Library"
                url = "http://lwjgl.org/"

                licenses {
                    license {
                        name = "BSD"
                        url = "http://lwjgl.org/license.php"
                        distribution = "repo"
                    }
                }

                scm {
                    url = "http://java-game-lib.svn.sourceforge.net/viewvc/java-game-lib/trunk/"
                    connection = "https://java-game-lib.svn.sourceforge.net/svnroot/java-game-lib"
                }

                developers {
                    developer {
                        id = "Developers"
                        url = "http://lwjgl.org/credits.php"
                    }
                }
            }
        }
    }
    setupRepositories(repositories)
}

def static setupRepositories(RepositoryHandler repositories) {
    def ENV = System.getenv()
    if (ENV.MAVEN_PUBLISH_CREDENTIALS) {
        repositories.maven {
            url 'https://repo.legacyfabric.net/repository/legacyfabric'
            credentials {
                username ENV.MAVEN_PUBLISH_CREDENTIALS.split(":")[0]
                password ENV.MAVEN_PUBLISH_CREDENTIALS.split(":")[1]
            }
            authentication {
                basic(BasicAuthentication)
            }
        }
    }
}

def os_arch = getArch(System.getProperty("os.arch"))
def target_arch = getArch(System.getProperty("targetArch", os_arch))

if (os_arch == target_arch) {
    compile_native.finalizedBy(":lwjgl:nativeTest")
}