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 (ext.jmeGitTag != null)
    ext.jmeEngineVersion = "3.1.0-" + ext.jmeGitTag + "-SNAPSHOT"
else
    ext.jmeEngineVersion = "3.1.0-master-SNAPSHOT" // Specify the Engine Version to be used.


configurations {
    corelibs
    optlibs
    testdatalibs
    examplelibs
}

dependencies {

    corelibs dep("com.github.xbuf:jme3_xbuf:0.8.4", 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-jbullet:$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-bullet:$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:$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)
                }
            }
        }

        
        
        // 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]}!/"
                
                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 buildSdk(dependsOn: [copyBaseLibs, copyProjectLibs, createProjectXml, createBaseXml, copyTestSources, overrideHarness]) <<{
    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 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()
}


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