jMonkeyEngine-sdk/build.gradle

//ant.importBuild 'build.xml'
import groovy.xml.MarkupBuilder
import java.util.zip.ZipFile

apply from: 'gradle/libs/digest.gradle'
apply from: file('version.gradle')


if (!hasProperty('mainClass')) {
    ext.mainClass = ''
}

repositories {
    mavenLocal()
    jcenter {
        url "http://jcenter.bintray.com/"
    }
    maven {
        url "http://updates.jmonkeyengine.org/maven/"
    }
    maven {
        url 'http://nifty-gui.sourceforge.net/nifty-maven-repo/'
    }
    maven { url "https://jitpack.io" }

}

if (System.getenv('TRAVIS') != null) {
    /*if (System.env.TRAVIS_TAG != "") {
        ext.jmeEngineVersion = "3.1.0-" + System.env.TRAVIS_TAG + "-SNAPSHOT"
    } else {*/
        ext.jmeEngineVersion = "3.1.0-stable" // Use Beta 2 instead of 3.1.0-master-SNAPSHOT
    //}
} else {
    ext.jmeEngineVersion = "3.1.0-stable" // In case you build of the HEAD of 3.1, you need to change that to 3.1.0-SNAPSHOT again
}

configurations {
    corelibs
    optlibs
    testdatalibs
    examplelibs
}

dependencies {

    corelibs dep("com.github.xbuf:jme3_xbuf:0.9.1", false, false)

    corelibs dep("org.jmonkeyengine:jme3-core:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-desktop:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-lwjgl:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-effects:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-blender:$jmeEngineVersion", true, true)

    corelibs dep("org.jmonkeyengine:jme3-bullet:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-bullet-native:$jmeEngineVersion", true, true)
    corelibs dep(fileTree("lib"), false, false)
    corelibs dep("org.jmonkeyengine:jme3-jogg:$jmeEngineVersion", true, true)

    corelibs dep("org.jmonkeyengine:jme3-networking:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-niftygui:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-plugins:$jmeEngineVersion", true, true)
    corelibs dep("org.jmonkeyengine:jme3-terrain:$jmeEngineVersion", true, true)

    optlibs dep("org.jmonkeyengine:jme3-jbullet:$jmeEngineVersion", true, true)
    optlibs dep("org.jmonkeyengine:jme3-jogl:$jmeEngineVersion", true, true)
    optlibs dep("org.jmonkeyengine:jme3-android:$jmeEngineVersion", true, true)
    optlibs dep("org.jmonkeyengine:jme3-ios:$jmeEngineVersion", true, true)
    optlibs dep("org.jmonkeyengine:jme3-android-native:$jmeEngineVersion", true, true)
    optlibs dep("org.jmonkeyengine:jme3-bullet-native-android:$jmeEngineVersion", true, true)
    testdatalibs dep("org.jmonkeyengine:jme3-testdata:$jmeEngineVersion", false, false)

    examplelibs dep("org.jmonkeyengine:jme3-examples:$jmeEngineVersion", false, true)

}

def dep(coords, javadoc = false, sources = false) {

    def result = [dependencies.create(coords)]

    if (javadoc) result << dependencies.create("$coords:javadoc")

    if (sources) result << dependencies.create("$coords:sources")

    result

}



artifacts {
    //    jar null
}

task checkPlatformConfig {
    description = "Downloads the NetBeans platform base and registers it in the SDK project if needed"
    def platformFile = file("nbproject/private/platform-private.properties")
    if(!platformFile.exists()){
        def netbeansFolder = file("netbeans")
        if(!netbeansFolder.exists() || netbeansFolder.list().length == 0){
            println "Downloading NetBeans Platform base, this only has to be done once.."
            def f = file("netbeans.zip")
            new URL(netbeansUrl).withInputStream{ i -> f.withOutputStream{ it << i }}
            copy{
                from zipTree(f)
                into "."
            }
            f.delete()
        }
        file("nbproject/private/").mkdirs()
        platformFile.createNewFile()
        platformFile.write("nbplatform.default.netbeans.dest.dir=${netbeansFolder.absolutePath.replace('\\','/')}\r\n"+\
                           "nbplatform.default.harness.dir=${netbeansFolder.absolutePath.replace('\\','/')}/harness\r\n")
    }
}

task copyBaseLibs(dependsOn:configurations.corelibs) <<{
    description "Copies the library files needed to run the SDK to "+
                "jme3-core-baselibs and jme3-core-libraries"

    // for each dependency in corelibs..
    //project.configurations.corelibs.dependencies.each {dep ->
    //println(project.configurations.corelibs.dependencies)
   
    project.configurations.corelibs.collect {file ->
        // copy built jme3 jar files to jme3-core-baselibs
        if (file.name.startsWith("jme3") && !isSourceOrJavadoc(file.name)){
            copy {
                from file
                into "jme3-core-baselibs/release/modules/ext/"
            }
        }else if( !isSourceOrJavadoc(file.name)){
            copy {
                from file
                into "jme3-core-libraries/release/modules/ext/"
            }
        }
    }
    
}

copyBaseLibs.inputs.files configurations.corelibs.resolve()
copyBaseLibs.outputs.dir "jme3-core-baselibs/release/modules/ext/"
copyBaseLibs.outputs.dir "jme3-core-libraries/release/modules/ext/"

def isSourceOrJavadoc(dep){
    return isSource(dep) || isJavadoc(dep)
}

def isSource(dep){
    return dep.endsWith("-sources.jar")
}

def isJavadoc(dep){
    return dep.endsWith("-javadoc.jar")
}
def isJmeDep(dep) {
    return dep.startsWith("jme3")
}

task createBaseXml(dependsOn: configurations.corelibs) <<{
    description "Creates the project.xml files for "+
                "jme3-core-baselibs and jme3-core-libraries"
    def jmeJarFiles = [] // jme3 jar files
    def externalJarFiles = [] // external jar files

    // collect jar files
    project.configurations.corelibs.collect {file ->
        // copy built jme3 jar files to jme3-core-baselibs
        if (file.name.startsWith("jme3") && !isSourceOrJavadoc(file.name)){
        
            //collect jme jars
            if(!jmeJarFiles.contains(file)) {
                jmeJarFiles.add(file)
            }
            
        } else if(!isSourceOrJavadoc(file.name)) {
            //collect external jars
            externalJarFiles.add(file)
            
        }

    }
  
    // collect base packages
    def packages = []
    jmeJarFiles.each{jarFile ->
        ZipFile file = new ZipFile(jarFile)
        file.entries().each { entry ->
            if(entry.name.endsWith('.class')){
                // TODO: "/" works on windows?
                def pathPart = entry.name.substring(0,entry.name.lastIndexOf('/'))
                def classPath = pathPart.replace('/','.');
                if(!packages.contains(classPath)){
                    packages.add(classPath)
                }
            }
        }
    }

    // collect library packages
    def extPackages = []
    externalJarFiles.each{jarFile ->
        ZipFile file = new ZipFile(jarFile)
        file.entries().each { entry ->
            if(entry.name.endsWith('.class')){
                // TODO: "/" works on windows?
                def pathPart = entry.name.substring(0,entry.name.lastIndexOf('/'))
                def classPath = pathPart.replace('/','.');
                if(!extPackages.contains(classPath)){
                    extPackages.add(classPath)
                }
            }
        }
    }

    def writer = new StringWriter()
    def xml = new MarkupBuilder(writer)
    xml.mkp.xmlDeclaration(version:'1.0')
    xml.project(xmlns:"http://www.netbeans.org/ns/project/1"){
        type "org.netbeans.modules.apisupport.project"
        configuration {
            data(xmlns:"http://www.netbeans.org/ns/nb-module-project/3") {
                "code-name-base" "com.jme3.gde.core.baselibs"
                "suite-component"{}
                "module-dependencies"{
                    dependency{
                        "code-name-base" "com.jme3.gde.core.libraries"
                        "build-prerequisite"{}
                        "compile-dependency"{}
                        "run-dependency"{
                            "release-version" "1"
                            "specification-version" jmeVersion
                        }
                    }
                }
                "public-packages"{
                    packages.each{
                        "package" it
                    }
                }
                jmeJarFiles.each{jarFile ->
                    "class-path-extension"{
                        "runtime-relative-path" "ext/${jarFile.name}"
                        "binary-origin" "release/modules/ext/${jarFile.name}"
                    }
                }
            }
        }
    }
    // write XML file
    File baselibsProjectFile = file("jme3-core-baselibs/nbproject/project.xml");
    baselibsProjectFile.write(writer.toString())

    def extWriter = new StringWriter()
    def extXml = new MarkupBuilder(extWriter)
//    extXml.mkp.xmlDeclaration(version:'1.0')
    extXml.project(xmlns:"http://www.netbeans.org/ns/project/1"){
        type "org.netbeans.modules.apisupport.project"
        configuration {
            data(xmlns:"http://www.netbeans.org/ns/nb-module-project/3") {
                "code-name-base" "com.jme3.gde.core.libraries"
                "suite-component"{}
                "module-dependencies"{}
                "public-packages"{
                    extPackages.each{
                        "package" it
                    }
                }
                externalJarFiles.each{jarFile ->
                    "class-path-extension"{
                        "runtime-relative-path" "ext/${jarFile.name}"
                        "binary-origin" "release/modules/ext/${jarFile.name}"
                    }
                }
            }
        }
    }
    // write XML file
    File librariesProjectFile = file("jme3-core-libraries/nbproject/project.xml");
    librariesProjectFile.write(extWriter.toString())
}
createBaseXml.inputs.files configurations.corelibs.resolve()
createBaseXml.outputs.file "jme3-core-baselibs/nbproject/project.xml"
createBaseXml.outputs.file "jme3-core-libraries/nbproject/project.xml"

task copyProjectLibs(dependsOn: [configurations.corelibs, configurations.testdatalibs]) <<{
    description "Copies the jar files needed to supply the J2SE Libraries in the "+
                "SDK to jme3-project-baselibs and jme3-project-libraries"

    // for each dependency in corelibs and optlibs..
    def deps = []
    deps.addAll(project.configurations.corelibs.files)
    deps.addAll(project.configurations.optlibs.files)
    deps.each {dep ->
        // copy jme3 jar files, sources and javadocs to jme3-project-baselibs
        
        if(isSource(dep.name)){
            copy {
                from dep
                into "jme3-project-baselibs/release/libs/"
            }
        } else if(isJavadoc(dep.name)){
            copy {
                from dep
                into "jme3-project-baselibs/release/libs/"
            }
        } else if(isJmeDep(dep.name)){
            copy {
                from dep
                into "jme3-project-baselibs/release/libs/"
            }
        } else{
            copy {
                from dep
                into "jme3-project-libraries/release/libs/"
            }
        }
       
    }

    project.configurations.testdatalibs.files.each {dep ->
        // copy jme3 test data to jme3-project-testdata
        if(isJmeDep(dep.name)){
            copy {
                from dep
                into "jme3-project-testdata/release/libs/"
                rename ("jme3-testdata(.*)", "jme3-testdata.jar")
            }
        }
    }
}
copyProjectLibs.inputs.files configurations.corelibs.resolve()
copyProjectLibs.inputs.files configurations.optlibs.resolve()
copyProjectLibs.inputs.files configurations.testdatalibs.resolve()
copyProjectLibs.outputs.dir "jme3-project-baselibs/release/libs/"
copyProjectLibs.outputs.dir "jme3-project-libraries/release/libs/"
copyProjectLibs.outputs.dir "jme3-project-testdata/release/libs/"

// workaround method to add a tag with the name "name" and "file" to an XML MarkupBuilder
def makeName(builder, nameR) { builder.name nameR }
def makeFile(builder, nameR) { builder.file(name:nameR, url:nameR) }

task createProjectXml(dependsOn: configurations.corelibs) <<{
    description "Creates needed J2SE library and layer XML files in jme3-project-baselibs"

    def eol = System.properties.'line.separator'
    def j2seLibraries = [] // created J2SE library descriptors

    
   
    // for each dependency in corelibs..
    def deps = []
    deps.addAll(project.configurations.corelibs.dependencies)
    deps.addAll(project.configurations.optlibs.dependencies)
    deps.each {dep ->
        def jmeJarFiles = [] // jme3 jar files
        def jmeSourceFiles = [] // jme3 sources
        def jmeJavadocFiles = [] // jme3 javadoc
        def externalJarFiles = [] // external jar files
        if(j2seLibraries.contains(dep.name+".xml")){
            return;
        }

        j2seLibraries.add(dep.name+".xml")
        project.configurations.corelibs.files{ d -> return d.name == dep.name}.each{ file ->
            if(isSource(file.name)){
                if(!jmeSourceFiles.contains(file.name)){
                    jmeSourceFiles.add(file.name)
                }
            } else if(isJavadoc(file.name)){
                if(!jmeJavadocFiles.contains(file.name)){
                    jmeJavadocFiles.add(file.name)
                }
            } else if(isJmeDep(file.name)){
                if(!jmeJarFiles.contains(file.name)){
                    jmeJarFiles.add(file.name)
                }
            } else{
                if(!externalJarFiles.contains(file.name)){
                    externalJarFiles.add(file.name)
                }
            }
        }

        project.configurations.optlibs.files{ d -> return d.name == dep.name}.each{ file ->

            if(isSource(file.name)){
                if(!jmeSourceFiles.contains(file.name)){
                    jmeSourceFiles.add(file.name)
                }
            } else if(isJavadoc(file.name)){
                if(!jmeJavadocFiles.contains(file.name)){
                    jmeJavadocFiles.add(file.name)
                }
            } else if(isJmeDep(file.name)){
                if(!jmeJarFiles.contains(file.name)){
                    jmeJarFiles.add(file.name)
                }
            } else {
                if(!externalJarFiles.contains(file.name)){
                    externalJarFiles.add(file.name)
                }
            }
        }
        
        // Workarounds where the automatic dependency detection did not work. This is mainly when there are runtime dependencies which are not available as artifacts
        if (dep.name.equals("jme3-jbullet")) {
            externalJarFiles.add("jbullet.jar")
            externalJarFiles.add("stack-alloc.jar")
        }

        
        
        // create J2SE library descriptor xml file
        def libraryWriter = new StringWriter()
        def libraryXml = new MarkupBuilder(libraryWriter)
//        xml.mkp.xmlDeclaration(version:'1.0')
        libraryWriter << '<?xml version="1.0" encoding="UTF-8"?>' << eol
        libraryWriter << '<!DOCTYPE library PUBLIC "-//NetBeans//DTD Library Declaration 1.0//EN" "http://www.netbeans.org/dtds/library-declaration-1_0.dtd">' << eol
        libraryXml.library(version:"1.0", encoding: "UTF-8"){
            makeName(libraryXml, "${dep.name}")
            type "j2se"
            "localizing-bundle" "com.jme3.gde.project.baselibs.Bundle"
            volume{
                type "classpath"
                
                resource "jar:nbinst://com.jme3.gde.project.baselibs/libs/${jmeJarFiles[0]}!/"
                
                /* Usually we don't add all the jmeJarFiles, this is because e.g. each library depends on core,
                 * some depend on jme3-terrain etc, but it's the users duty to add the correct libraries.
                 * If we would add all those each library would have it's one jme3-core, which might even lead
                 * to build errors then.
                 */
                if (dep.name.equals("jme3_xbuf")) {
                    jmeJarFiles.each{jar ->
                        if (jar.startsWith("jme3_xbuf")) {
                            /* Technically you would only need the loaders, not the spatial viewer,
                             * but users can edit the library if they want to strip off
                             * the last few possible kilobytes */
                            resource "jar:nbinst://com.jme3.gde.project.baselibs/libs/$jar!/"
                        }
                    }
                }
                
                externalJarFiles.each{jar ->
                    resource "jar:nbinst://com.jme3.gde.project.libraries/libs/${jar}!/"
                }
            }
            volume{
                type "src"
                jmeSourceFiles.each{jar ->
                    resource "jar:nbinst://com.jme3.gde.project.baselibs/libs/${jar}!/"
                }
            }
            volume{
                type "javadoc"
                jmeJavadocFiles.each{jar ->
                    resource "jar:nbinst://com.jme3.gde.project.baselibs/libs/${jar}!/"
                }
            }
        }
        // write XML file
        File libraryXmlFile = file("jme3-project-baselibs/src/com/jme3/gde/project/baselibs/${dep.name}.xml");
        libraryXmlFile.write(libraryWriter.toString())
    }

    // create layer.xml file with entries of library xml files
    def layerWriter = new StringWriter()
    def layerXml = new MarkupBuilder(layerWriter)
//    layerXml.mkp.xmlDeclaration(version:'1.0')
    layerWriter << '<?xml version="1.0" encoding="UTF-8"?>' << eol
    layerWriter << '<!DOCTYPE filesystem PUBLIC "-//NetBeans//DTD Filesystem 1.1//EN" "http://www.netbeans.org/dtds/filesystem-1_1.dtd">' << eol
    layerXml.filesystem{
        folder(name:"org-netbeans-api-project-libraries"){
            folder(name:"Libraries"){
                j2seLibraries.each{lib ->
                    makeFile(layerXml, lib)
                }
            }
        }
    }
    File layerXmlFile = file("jme3-project-baselibs/src/com/jme3/gde/project/baselibs/layer.xml");
    layerXmlFile.write(layerWriter.toString())
}
createProjectXml.inputs.files configurations.corelibs.resolve()
createProjectXml.inputs.files configurations.optlibs.resolve()
createProjectXml.outputs.dir "jme3-project-baselibs/src/com/jme3/gde/project/baselibs/"

task copyTestSources <<{
    project.configurations.examplelibs.files.each{dep ->
        if(isSource(dep.name)){
            copy{
                from {
                    zipTree(dep)
                }
                into "JME3TestsTemplate/src/"
            }
            copy{
                from {
                    zipTree(dep)
                }
                into "JME3TestsTemplateAndroid/src/"
            }
        }
    }
}
copyTestSources.inputs.files project.configurations.examplelibs
copyTestSources.outputs.dir "JME3TestsTemplate/src/"
copyTestSources.outputs.dir "JME3TestsTemplateAndroid/src/"

ant.properties['plugins.version'] = jmeVersion
ant.properties['app.version']= jmePomVersion
ant.properties['nbm.revision']= jmeNbmRevision

task overrideHarness(dependsOn: checkPlatformConfig) << {
    def props = new Properties()
    props.load(new FileInputStream("harness-override/override.properties"))

    def patch_file = { f ->
        def g = file("harness-override/" + f.getName())
        if (!f.exists()) {
            throw new GradleException('Cannot find targetFile: ' +  f.getAbsolutePath());
        }

        if (!g.exists()) {
            throw new GradleException('Cannot find sourceFile: ' +  g.getAbsolutePath());
        }

        if (getSHA256Hash(f) == props[f.getName() + ".hashAfter"]) {
            println "> Harness file \"" + f.getName() + "\" is already patched!"
            return; /* Already patched */
        }
        if (getSHA256Hash(f) == props[f.getName() + ".hashBefore"]) {
            println "> Will patch harness file \"" + f.getName() + "\"!"

            if (getSHA256Hash(g) != props[g.getName() + ".hashAfter"]) {
                throw new GradleException("Dangerous Checksum Mismatch: sourceFile \"" + g.getName() + "\" doesn't equal to its hashAfter hash. This probably means someone changed this file but forgot to update said hash or someone tried to invade the SDK by spreading his exe.")
            }

            copy {
                from g
                into f.getParent()
            }

        } else {
            throw new GradleException('Checksum Mismatch: targetFile ' + f.getName() + ' has invalid hash ' + getSHA256Hash(f) +  '. Did you update Netbeans without changing harness-override/override.properties?');
        }
    }

    patch_file(file("netbeans/harness/launchers/app.exe"));
    patch_file(file("netbeans/harness/launchers/app64.exe"));
    patch_file(file("netbeans/harness/launchers/pre7_app.exe"));

}
overrideHarness.outputs.files([ 'netbeans/harness/launchers/app.exe', 'netbeans/harness/launchers/app64.exe', 'netbeans/harness/launchers/pre7_app.exe'])
overrideHarness.inputs.files([ 'netbeans/harness/launchers/app.exe', 'netbeans/harness/launchers/app64.exe', 'netbeans/harness/launchers/pre7_app.exe', 'harness-override/override.properties'])

task downloadAvian() << {
    def avianFile = file("jme3-ios/src/com/jme3/gde/ios/avian-openjdk-mac.zip")
    
    if (!avianFile.exists())
    {
        new URL('https://bintray.com/mefisto94/jme-sdk-storage/download_file?file_path=avian-openjdk-mac.zip').withInputStream{ i -> avianFile.withOutputStream{ it << i }}
    }
}

task buildSdk(dependsOn: [copyBaseLibs, copyProjectLibs, createProjectXml, createBaseXml, copyTestSources, overrideHarness, downloadAvian]) <<{
    ant.propertyfile(file: "nbproject/project.properties") {
        entry( key: "plugins.version", value: "${jmeVersion}")
        entry( key: "app.version", value: "${jmePomVersion}")
        entry( key: "nbm.revision", value: "${jmeNbmRevision}")
    }
    ant.ant(dir: ".", antfile: "build.xml", target: "build")
}
buildSdk.inputs.files configurations.corelibs.resolve()
buildSdk.inputs.files configurations.optlibs.resolve()
file('.').eachDir{
    if(it.name.startsWith("jme3-") && it.isDirectory()){
        buildSdk.inputs.dir it
    }
}
buildSdk.outputs.dir "build"

task run(dependsOn: buildSdk) << {
    ant.ant(dir: ".", antfile: "build.xml", target: "run")
}

task cleanSdk() <<{
    ant.ant(dir: ".", antfile: "build.xml", target: "clean")
    file("jme3-core-baselibs/release/").deleteDir()
    file("jme3-core-libraries/release/").deleteDir()
    file("jme3-core-baselibs/nbproject/project.xml").delete()
    file("jme3-core-libraries/nbproject/project.xml").delete()
    file("jme3-project-baselibs/release/").deleteDir()
    file("jme3-project-libraries/release/").deleteDir()
    file("jme3-project-testdata/release/").deleteDir()
    file("JME3TestsTemplate/src/jme3test/").deleteDir()
    file("JME3TestsTemplateAndroid/src/jme3test/").deleteDir()
}

task extractPlatformIndependent(type: Copy) {
    from zipTree('dist/jmonkeyplatform.zip')
    into "dist/temp/"
    
    exclude("jmonkeyplatform/etc/jmonkeyplatform.conf")
}

task patchPlatformIndependent(type: Copy, dependsOn: extractPlatformIndependent) {
    from zipTree('dist/jmonkeyplatform.zip')
    into "dist/temp/"
    
    include("jmonkeyplatform/etc/jmonkeyplatform.conf")

    filter { String line ->
        line.startsWith('jdkhome=') ? '#jdkhome="/path/to/jdk"': line
    }

    doLast {
        delete(file('dist/jmonkeyplatform.zip'))
    }
}

task fixPlatformIndependent(dependsOn: patchPlatformIndependent, type: Zip) {
    description = "We compile our installers with the bundled jdk, but the platform independent zip doesn't have the jdk. For this we need to change the jmonkeyplatform.zip after building the installers to not have a jdk bundled"

    from 'dist/temp'
    archiveName = 'jmonkeyplatform.zip'
    destinationDir = file('dist')

    doLast {
        delete("dist/temp")
    }
}

//jar.dependsOn(buildSdk)
//clean.dependsOn(cleanSdk)