build: update to gradle 2.13

build.gradle

@@ -118,7 +118,7 @@ task mergedSource(type: Copy){
 }
 
 task wrapper(type: Wrapper, description: 'Creates and deploys the Gradle wrapper to the current directory.') {
-    gradleVersion = '2.2.1'
+    gradleVersion = '2.13'
 }
 
 ext {

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Mon Dec 01 20:04:11 EST 2014
+#Sat Apr 30 16:44:31 EDT 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-bin.zip

gradlew

@@ -6,12 +6,30 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+# Attempt to set APP_HOME
-DEFAULT_JVM_OPTS=""
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
@@ -30,6 +48,7 @@ die ( ) {
 cygwin=false
 msys=false
 darwin=false
+nonstop=false
 case "`uname`" in
   CYGWIN* )
     cygwin=true
@@ -40,31 +59,11 @@ case "`uname`" in
   MINGW* )
     msys=true
     ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
-APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
@@ -90,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`

gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,7 +46,7 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
 if "%@eval[2+2]" == "4" goto 4NT_args

jme3-bullet-native/build.gradle

@@ -1,46 +1,97 @@
 apply plugin: 'cpp'
 
-String bulletSrcPath = bulletFolder + '/src'
+import java.nio.file.Paths
 
-if (!hasProperty('mainClass')) {
+String bulletSrcPath = bulletFolder + '/src'
-    ext.mainClass = ''
-}
 
 dependencies {
     compile project(':jme3-bullet')
 }
 
-// Defines created C++ libraries
+model {
-libraries {
+    components {
-    bulletjme {
+        bulletjme(NativeLibrarySpec) {
+            targetPlatform 'Windows64'
+            targetPlatform 'Windows32'
+            targetPlatform 'Mac64'
+            targetPlatform 'Mac32'
+            targetPlatform 'Linux64'
+            targetPlatform 'Linux32'
+
+            sources {
+                cpp {
+                    source {
+                        srcDir 'src/native/cpp'
+                        srcDir bulletSrcPath
+                        exclude 'BulletMultiThreaded/GpuSoftBodySolvers/**'
+                        include '**/*.cpp'
+                    }
+                    exportedHeaders {
+                        srcDir 'src/native/cpp'
+                        srcDir bulletSrcPath
+                        include '**/*.h'
+                    }
+                }
+            }
+        }
+    }
+    
+    binaries {
+        withType(SharedLibraryBinarySpec) {
+            def projectPath = project.projectDir.absolutePath
+            def javaHome = org.gradle.internal.jvm.Jvm.current().javaHome
+            def os = targetPlatform.operatingSystem.name
+            def arch = targetPlatform.architecture.name
+            def fileName = sharedLibraryFile.name
+            
+            // Gradle decided to change underscores to dashes - fix that.
+            arch = arch.replaceAll('-', '_')
+            
+            // For all binaries that can't be built on the current system
+            if (buildNativeProjects != "true") {
+                buildable = false
+            }
+
+            if (!buildable) {
+                if (sharedLibraryFile.exists()) {
+                    // Add binary to jar file if the binary exists in the build folder already,
+                    // e.g. when the build of jme3-bullet-native has been run on a virtual box
+                    // and the project hasn't been cleaned yet.
+                    jar.into("native/${os}/${arch}") {
+                        from sharedLibraryFile
+                    }
+                } else {
+                    // Get from libs folder if no fresh build is available in the build folder and add to jar file
+                    def precompiledFile = Paths.get(projectPath, 'libs', 'native', os, arch, fileName).toFile()
+                    if (precompiledFile.exists()) {
+                        jar.into("native/${os}/${arch}") {
+                            from precompiledFile
                         }
-    all {
+                    }
-        binaries.all {
+                }
+                return
+            }
+
             if (toolChain in VisualCpp) {
-                cppCompiler.args "/I${org.gradle.internal.jvm.Jvm.current().javaHome}\\include"
+                cppCompiler.args "/I$javaHome\\include"
             } else{
-                cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include"
+                cppCompiler.args '-I', "$javaHome/include"
             }
 
-            if (targetPlatform.operatingSystem.name == "osx") {
+            if (os == "osx") {
-                cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include/darwin"
+                cppCompiler.args '-I', "$javaHome/include/darwin"
-            } else if (targetPlatform.operatingSystem.name == "linux") {
+            } else if (os == "linux") {
                 cppCompiler.args "-fvisibility=hidden"
-                cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include/linux"
+                cppCompiler.args '-I', "$javaHome/include/linux"
                 cppCompiler.args "-fPIC"
                 cppCompiler.args "-fpermissive"
                 linker.args "-fvisibility=hidden"
-
+            } else if (os == "windows") {
-//                cppCompiler.args "-static-libgcc"
-//                cppCompiler.args "-static-libstdc++"
-//                linker.args "-static-libgcc"
-//                linker.args "-static-libstdc++"
-            } else if (targetPlatform.operatingSystem.name == "windows") {
                 if (toolChain in Gcc) {
                     if (toolChain.name.startsWith('mingw')) {
-                        cppCompiler.args '-I', "${projectDir}/src/native/cpp/fake_win32"
+                        cppCompiler.args '-I', "$projectDir/src/native/cpp/fake_win32"
                     } else {
-                        cppCompiler.args '-I', "${org.gradle.internal.jvm.Jvm.current().javaHome}/include/win32"
+                        cppCompiler.args '-I', "$javaHome/include/win32"
                     }
                     cppCompiler.args "-fpermissive"
                     cppCompiler.args "-static"
@@ -48,45 +99,59 @@ libraries {
                     linker.args "-Wl,--exclude-all-symbols"
                 }
                 else if (toolChain in VisualCpp) {
-                    cppCompiler.args "/I${org.gradle.internal.jvm.Jvm.current().javaHome}\\include\\win32"
+                    cppCompiler.args "/I$javaHome\\include\\win32"
                 }
                 cppCompiler.define('WIN32')
-//                linker.args 'Shlwapi.lib', 'Advapi32.lib'
-            }
             }
+            
+            tasks.all { dependsOn unzipBulletIfNeeded }
+
+            // Add output to jar file
+            jar.into("native/${os}/${arch}") {
+                from sharedLibraryFile
             }
-}
             
-// C++ sources for binary compilation
+            // Add depend on build
-sources {
+            jar.dependsOn tasks
-    bulletjme {
+            // Add output to libs folder
-        cpp {
+            task "copyBinaryToLibs${targetPlatform.name}"(type: Copy, dependsOn: tasks) {
-            source {
+                from sharedLibraryFile
-                srcDir 'src/native/cpp'
+                into "libs/native/${os}/${arch}"
-                srcDir bulletSrcPath
-                exclude 'BulletMultiThreaded/GpuSoftBodySolvers/**'
-                include '**/*.cpp'
             }
-            exportedHeaders {
+            // Add depend on copy
-                srcDir 'src/native/cpp'
+            jar.dependsOn("copyBinaryToLibs${targetPlatform.name}")
-                srcDir bulletSrcPath
-                include '**/*.h'
         }
+        withType(StaticLibraryBinarySpec) {
+            buildable = false
         }
     }
-}
 
-// Java source sets for IDE acces and source jar bundling / mavenization
+    platforms {
-sourceSets {
+        Windows32 {
-    main {
+            architecture "x86"
-        java {
+            operatingSystem "windows"
-            srcDir 'src/native/cpp'
+        }
+        Windows64 {
+            architecture "x86_64"
+            operatingSystem "windows"
+        }
+        Mac32 {
+            architecture "x86"
+            operatingSystem "osx"
+        }
+        Mac64 {
+            architecture "x86_64"
+            operatingSystem "osx"
+        }
+        Linux32 {
+            architecture "x86"
+            operatingSystem "linux"
+        }
+        Linux64 {
+            architecture "x86_64"
+            operatingSystem "linux"
         }
     }
-}
-
-// Set of target platforms, will be available based on build system
-model {
 
     toolChains {
         gcc(Gcc)
@@ -112,112 +177,40 @@ model {
             target("windows_x86_64")
         }
     }
+}
 
-    platforms{
+// Java source sets for IDE access and source jar bundling / mavenization
-//    osx_universal { // TODO: universal binary doesn't work?
+sourceSets {
-//        architecture 'x86_64'
+    main {
-//        architecture 'x86'
+        java {
-//        operatingSystem 'osx'
+            srcDir 'src/native/cpp'
-//    }
-        osx_x86 {
-            architecture "x86"
-            operatingSystem "osx"
-        }
-        osx_x86_64 {
-            architecture "x86_64"
-            operatingSystem "osx"
-        }
-        linux_x86 {
-            architecture "x86"
-            operatingSystem "linux"
-        }
-        linux_x86_64 {
-            architecture "x86_64"
-            operatingSystem "linux"
-        }
-        windows_x86 {
-            architecture "x86"
-            operatingSystem "windows"
-        }
-        windows_x86_64 {
-            architecture "x86_64"
-            operatingSystem "windows"
         }
     }
 }
 
-// Download bullet if not available
 task downloadBullet(type: MyDownload) {
     sourceUrl = bulletUrl
     target = file(bulletZipFile)
 }
 
-// Unzip bullet if not available
 task unzipBullet(type: Copy) {
-    def zipFile = file(bulletZipFile)
+    from zipTree(bulletZipFile)
-    def outputDir = file(".")
+    into file('.')
-
-    from zipTree(zipFile)
-    into outputDir
 }
+
 unzipBullet.dependsOn {
-    def zipFilePath = project.projectDir.absolutePath + File.separator + bulletZipFile
+    if (!file(bulletZipFile).exists()) {
-    def zipFile = new File(zipFilePath)
-    if (!zipFile.exists()) {
         downloadBullet
     }
 }
 
-compileJava.dependsOn {
+task unzipBulletIfNeeded << {
-    if(buildNativeProjects=="true"){
-        def bulletUnzipDir = new File(project.projectDir.absolutePath + File.separator + bulletFolder)
-        if (!bulletUnzipDir.isDirectory()) {
-            unzipBullet
-        }
-    }
-}
-
-binaries.withType(StaticLibraryBinarySpec) {
-    buildable = false
 }
 
-// Adds all available binaries to java jar task
+unzipBulletIfNeeded.dependsOn {
-binaries.withType(SharedLibraryBinary) { binary ->
+    if (buildNativeProjects == "true" && !file(bulletFolder).isDirectory()) {
-    // For all binaries that can't be built on the current system
+        unzipBullet
-    if(buildNativeProjects!="true"){
-        buildable = false;
-    }
-    if (!buildable) {
-        //Get from libs folder if no fresh build is available in the build folder and add to jar file
-        if(!binary.tasks.outputFile.get(0).exists()){
-            def fileName = binary.tasks.outputFile.get(0).getName();
-            def precompiledFile = new File(project.projectDir.absolutePath + File.separator + "libs" + File.separator + "native" + File.separator + "${targetPlatform.operatingSystem.name}" + File.separator + "${targetPlatform.architecture.name}" + File.separator + "${fileName}")
-            if(precompiledFile.exists()){
-                jar.into("native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}") { from precompiledFile }
-            }
-            return
-        } else{
-            // Add binary to jar file if the binary exists in the build folder already,
-            // e.g. when the build of jme3-bullet-native has been run on a virtual box
-            // and the project hasn't been cleaned yet.
-            jar.into("native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}") { from binary.tasks.outputFile }
-            return
-        }
-    }
-
-    // For all binaries that can be built on the current system
-    def builderTask = binary.tasks
-    // Add output to jar file
-    jar.into("native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}") { from builderTask.outputFile }
-    // Add depend on build
-    jar.dependsOn builderTask
-    // Add output to libs folder
-    task "copyBinaryToLibs${targetPlatform}"(type: Copy, dependsOn: builderTask) {
-        from builderTask.outputFile
-        into "libs/native/${targetPlatform.operatingSystem.name}/${targetPlatform.architecture.name}"
     }
-    // Add depend on copy
-    jar.dependsOn("copyBinaryToLibs${targetPlatform}")
 }
 
 // Helper class to wrap ant dowload task
@@ -233,4 +226,3 @@ class MyDownload extends DefaultTask {
         ant.get(src: sourceUrl, dest: target)
     }
 }
-