diff --git a/.gitignore b/.gitignore
index dc6d9aec8..e8f636ab3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
**/.classpath
**/.settings
**/.project
+**/out/
/.gradle/
/.nb-gradle/
/.idea/
@@ -21,10 +22,9 @@
.DS_Store
/jme3-core/src/main/resources/com/jme3/system/version.properties
/jme3-*/build/
-/jme3-bullet-native/bullet.zip
/jme3-bullet-native/bullet3.zip
-/jme3-bullet-native/bullet-2.82-r2704/
-/jme3-bullet-native/bullet3-2.83.7/
+/jme3-bullet-native/bullet3-2.87/
+/jme3-bullet-native/src/native/cpp/com_jme3_bullet_*.h
/jme3-android-native/openal-soft/
/jme3-android-native/OpenALSoft.zip
/jme3-android-native/src/native/jme_decode/STBI/
diff --git a/.travis.yml b/.travis.yml
index c24f8941b..1425467ff 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,10 @@
language: java
-sudo: false
-dist: precise
+sudo: true
branches:
only:
- master
- - v3.1
+ - v3.2
matrix:
include:
@@ -14,7 +13,9 @@ matrix:
env: UPLOAD=true UPLOAD_NATIVE=true
- os: linux
jdk: openjdk7
+ dist: precise
- os: osx
+ osx_image: xcode9.3
env: UPLOAD_NATIVE=true
addons:
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 82ffeb4e8..7234481dd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -55,5 +55,5 @@ We generally abide by the standard Java Code Conventions. Besides that, just mak
## Documentation
-- How to edit the wiki - WIP
+- How to edit the [wiki](https://github.com/jMonkeyEngine/wiki).
- How to edit JavaDocs - WIP
diff --git a/README.md b/README.md
index 68d2d6204..b87abb203 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@ jMonkeyEngine
[![Build Status](https://travis-ci.org/jMonkeyEngine/jmonkeyengine.svg?branch=master)](https://travis-ci.org/jMonkeyEngine/jmonkeyengine)
-jMonkeyEngine is a 3D game engine for adventurous Java developers. It’s open-source, cross-platform, and cutting-edge. 3.1.0 is the latest stable version of the jMonkeyEngine 3 SDK, a complete game development suite. We'll release 3.1.x updates until the major 3.2 release arrives.
+jMonkeyEngine is a 3D game engine for adventurous Java developers. It’s open-source, cross-platform, and cutting-edge. 3.2.0 is the latest stable version of the jMonkeyEngine 3 SDK, a complete game development suite. We'll release 3.2.x updates until the major 3.3 release arrives.
The engine is used by several commercial game studios and computer-science courses. Here's a taste:
diff --git a/appveyor.yml b/appveyor.yml
index dc36e789e..00c9d5c26 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -3,10 +3,13 @@ version: 1.0.{build}.{branch}
branches:
only:
- master
+ - v3.2
only_commits:
files:
- jme3-bullet-native/
+ - appveyor.yml
+ - gradle.properties
skip_tags: true
@@ -34,13 +37,15 @@ build_script:
cache:
- C:\Users\appveyor\.gradle\caches
- C:\Users\appveyor\.gradle\wrapper
-- jme3-bullet-native\bullet3.zip
+- jme3-bullet-native\bullet3.zip -> gradle.properties
test: off
deploy: off
on_success:
- cmd: >-
+ if not defined encrypted_f0a0b284e2e8_key appveyor exit
+
openssl aes-256-cbc -K %encrypted_f0a0b284e2e8_key% -iv %encrypted_f0a0b284e2e8_iv% -in private\key.enc -out c:\users\appveyor\.ssh\id_rsa -d
git config --global user.email "appveyor"
diff --git a/build.gradle b/build.gradle
index e1af45a55..3ccd202a9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,10 +1,11 @@
buildscript {
repositories {
+ google()
jcenter()
}
dependencies {
- classpath 'com.android.tools.build:gradle:2.1.0'
- classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.5'
+ classpath 'com.android.tools.build:gradle:3.1.4'
+ classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
}
}
@@ -15,7 +16,7 @@ apply from: file('version.gradle')
subprojects {
if(!project.name.equals('jme3-android-examples')) {
apply from: rootProject.file('common.gradle')
- if (!['jme3-testdata', 'sdk'].contains(project.name)) {
+ if (!project.name.equals('jme3-testdata')) {
apply from: rootProject.file('bintray.gradle')
}
} else {
@@ -66,9 +67,9 @@ task createZipDistribution(type:Zip,dependsOn:["dist","libDist"], description:"P
archiveName "jME" + jmeFullVersion + ".zip"
into("/") {
from {"./dist"}
- }
+ }
into("/sources") {
- from {"$buildDir/libDist/sources"}
+ from {"$buildDir/libDist/sources"}
}
}
@@ -88,14 +89,14 @@ task dist(dependsOn: [':jme3-examples:dist', 'mergedJavadoc']){
task mergedJavadoc(type: Javadoc, description: 'Creates Javadoc from all the projects.') {
title = 'jMonkeyEngine3'
destinationDir = mkdir("dist/javadoc")
-
+
options.encoding = 'UTF-8'
// Allows Javadoc to be generated on Java 8 despite doclint errors.
if (JavaVersion.current().isJava8Compatible()) {
options.addStringOption('Xdoclint:none', '-quiet')
}
-
+
options.overview = file("javadoc-overview.html")
// Note: The closures below are executed lazily.
source subprojects.collect {project ->
@@ -115,10 +116,6 @@ task mergedSource(type: Copy){
}
-task wrapper(type: Wrapper, description: 'Creates and deploys the Gradle wrapper to the current directory.') {
- gradleVersion = '3.2.1'
-}
-
ext {
ndkCommandPath = ""
ndkExists = false
@@ -137,7 +134,7 @@ task configureAndroidNDK {
if (System.env.ANDROID_NDK != null) {
ndkBuildPath = System.env.ANDROID_NDK + File.separator + ndkBuildFile
}
-
+
if (new File(ndkBuildPath).exists()) {
ndkExists = true
ndkCommandPath = ndkBuildPath
diff --git a/common.gradle b/common.gradle
index d15f1c582..c396df30a 100644
--- a/common.gradle
+++ b/common.gradle
@@ -16,6 +16,9 @@ repositories {
maven {
url "http://nifty-gui.sourceforge.net/nifty-maven-repo"
}
+ flatDir {
+ dirs rootProject.file('lib')
+ }
}
dependencies {
diff --git a/gradle.properties b/gradle.properties
index 1cb84fcdd..0588a31a2 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,14 +1,14 @@
# Version number used for plugins, only 3 numbers (e.g. 3.1.3)
-jmeVersion = 3.2.0
+jmeVersion = 3.3.0
# Version used for application and settings folder, no spaces!
-jmeMainVersion = 3.2
+jmeMainVersion = 3.3
# Version addition pre-alpha-svn, Stable, Beta
jmeVersionTag = SNAPSHOT
# Increment this each time jmeVersionTag changes but jmeVersion stays the same
jmeVersionTagID = 0
# specify if JavaDoc should be built
-buildJavaDoc = false
+buildJavaDoc = true
# specify if SDK and Native libraries get built
buildNativeProjects = false
@@ -16,11 +16,11 @@ buildAndroidExamples = false
# Path to android NDK for building native libraries
#ndkPath=/Users/normenhansen/Documents/Code-Import/android-ndk-r7
-ndkPath = /opt/android-ndk-r10c
+ndkPath = /opt/android-ndk-r16b
# Path for downloading native Bullet
-bulletUrl = https://github.com/bulletphysics/bullet3/archive/2.86.1.zip
-bulletFolder = bullet3-2.86.1
+bulletUrl = https://github.com/bulletphysics/bullet3/archive/2.87.zip
+bulletFolder = bullet3-2.87
bulletZipFile = bullet3.zip
# POM settings
@@ -38,3 +38,4 @@ POM_INCEPTION_YEAR=2009
# Bintray settings to override in $HOME/.gradle/gradle.properties or ENV or commandline
bintray_user=
bintray_api_key=
+
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index ca78035ef..7a3265ee9 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index e89f72e3d..76e4690af 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,5 @@
-#Fri Nov 25 13:05:50 EST 2016
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.2.1-bin.zip
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-bin.zip
diff --git a/gradlew b/gradlew
index 27309d923..cccdd3d51 100755
--- a/gradlew
+++ b/gradlew
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
##############################################################################
##
@@ -33,11 +33,11 @@ DEFAULT_JVM_OPTS=""
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
-warn ( ) {
+warn () {
echo "$*"
}
-die ( ) {
+die () {
echo
echo "$*"
echo
@@ -154,11 +154,19 @@ if $cygwin ; then
esac
fi
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
- JVM_OPTS=("$@")
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
index f6d5974e7..e95643d6a 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -49,7 +49,6 @@ goto fail
@rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
:win9xME_args
@rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
:execute
@rem Setup the command line
diff --git a/jme3-android-examples/src/main/java/org/jmonkeyengine/jme3androidexamples/MainActivity.java b/jme3-android-examples/src/main/java/org/jmonkeyengine/jme3androidexamples/MainActivity.java
index 7bde9d9c9..83a378ef8 100644
--- a/jme3-android-examples/src/main/java/org/jmonkeyengine/jme3androidexamples/MainActivity.java
+++ b/jme3-android-examples/src/main/java/org/jmonkeyengine/jme3androidexamples/MainActivity.java
@@ -214,7 +214,7 @@ public class MainActivity extends AppCompatActivity implements OnItemClickListen
/**
* User clicked a view on the screen. Check for the OK and Cancel buttons
- * and either start the applicaiton or exit.
+ * and either start the application or exit.
* @param view
*/
public void onClick(View view) {
diff --git a/jme3-android/build.gradle b/jme3-android/build.gradle
index e49befecd..4caad528e 100644
--- a/jme3-android/build.gradle
+++ b/jme3-android/build.gradle
@@ -5,5 +5,5 @@ if (!hasProperty('mainClass')) {
dependencies {
compile project(':jme3-core')
compile project(':jme3-plugins')
- compile files('../lib/android.jar')
+ compileOnly 'android:android'
}
diff --git a/jme3-android/src/main/java/com/jme3/input/android/AndroidSensorJoyInput.java b/jme3-android/src/main/java/com/jme3/input/android/AndroidSensorJoyInput.java
index cdd7e6494..4232e6082 100644
--- a/jme3-android/src/main/java/com/jme3/input/android/AndroidSensorJoyInput.java
+++ b/jme3-android/src/main/java/com/jme3/input/android/AndroidSensorJoyInput.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -59,7 +59,7 @@ import java.util.logging.Logger;
/**
* AndroidSensorJoyInput converts the Android Sensor system into Joystick events.
* A single joystick is configured and includes data for all configured sensors
- * as seperate axes of the joystick.
+ * as separate axes of the joystick.
*
* Each axis is named according to the static strings in SensorJoystickAxis.
* Refer to the strings defined in SensorJoystickAxis for a list of supported
@@ -285,8 +285,8 @@ public class AndroidSensorJoyInput implements SensorEventListener {
}
/**
- * Calculates the device orientation based off the data recieved from the
- * Acceleration Sensor and Mangetic Field sensor
+ * Calculates the device orientation based off the data received from the
+ * Acceleration Sensor and Magnetic Field sensor
* Values are returned relative to the Earth.
*
* From the Android Doc
diff --git a/jme3-android/src/main/java/com/jme3/system/android/OGLESContext.java b/jme3-android/src/main/java/com/jme3/system/android/OGLESContext.java
index 508e81065..db185b002 100644
--- a/jme3-android/src/main/java/com/jme3/system/android/OGLESContext.java
+++ b/jme3-android/src/main/java/com/jme3/system/android/OGLESContext.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -136,7 +136,7 @@ public class OGLESContext implements JmeContext, GLSurfaceView.Renderer, SoftTex
// stops at the setFormat call without a crash.
// We look at the user setting for alpha bits and set the surfaceview
// PixelFormat to either Opaque, Transparent, or Translucent.
- // ConfigChooser will do it's best to honor the alpha requested by the user
+ // ConfigChooser will do its best to honor the alpha requested by the user
// For best rendering performance, use Opaque (alpha bits = 0).
int curAlphaBits = settings.getAlphaBits();
logger.log(Level.FINE, "curAlphaBits: {0}", curAlphaBits);
diff --git a/jme3-blender/src/main/java/com/jme3/asset/BlenderKey.java b/jme3-blender/src/main/java/com/jme3/asset/BlenderKey.java
index 3b72088ab..6dbb205b5 100644
--- a/jme3-blender/src/main/java/com/jme3/asset/BlenderKey.java
+++ b/jme3-blender/src/main/java/com/jme3/asset/BlenderKey.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -69,7 +69,7 @@ public class BlenderKey extends ModelKey {
*/
protected String usedWorld;
/**
- * User's default material that is set fo objects that have no material definition in blender. The default value is
+ * User's default material that is set for objects that have no material definition in blender. The default value is
* null. If the value is null the importer will use its own default material (gray color - like in blender).
*/
protected Material defaultMaterial;
@@ -476,9 +476,9 @@ public class BlenderKey extends ModelKey {
}
/**
- * This mehtod sets the name of the WORLD data block taht should be used during file loading. By default the name is
+ * This method sets the name of the WORLD data block that should be used during file loading. By default the name is
* not set. If no name is set or the given name does not occur in the file - the first WORLD data block will be used
- * during loading (assumin any exists in the file).
+ * during loading (assuming any exists in the file).
* @param usedWorld
* the name of the WORLD block used during loading
*/
@@ -487,7 +487,7 @@ public class BlenderKey extends ModelKey {
}
/**
- * This mehtod returns the name of the WORLD data block taht should be used during file loading.
+ * This method returns the name of the WORLD data block that should be used during file loading.
* @return the name of the WORLD block used during loading
*/
public String getUsedWorld() {
diff --git a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/constraints/SimulationNode.java b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/constraints/SimulationNode.java
index 711e0a338..279b5311d 100644
--- a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/constraints/SimulationNode.java
+++ b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/constraints/SimulationNode.java
@@ -237,7 +237,7 @@ public class SimulationNode {
}
}
- // ... add virtual tracks if neccessary, for bones that were altered but had no tracks before ...
+ // ... add virtual tracks if necessary, for bones that were altered but had no tracks before ...
for (Long boneOMA : alteredOmas) {
BoneContext boneContext = blenderContext.getBoneContext(boneOMA);
int boneIndex = skeleton.getBoneIndex(boneContext.getBone());
diff --git a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/curves/CurvesTemporalMesh.java b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/curves/CurvesTemporalMesh.java
index 51a5aeb63..2ad8d3ff2 100644
--- a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/curves/CurvesTemporalMesh.java
+++ b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/curves/CurvesTemporalMesh.java
@@ -37,7 +37,7 @@ import com.jme3.util.BufferUtils;
/**
* A temporal mesh for curves and surfaces. It works in similar way as TemporalMesh for meshes.
- * It prepares all neccessary lines and faces and allows to apply modifiers just like in regular temporal mesh.
+ * It prepares all necessary lines and faces and allows to apply modifiers just like in regular temporal mesh.
*
* @author Marcin Roguski (Kaelthas)
*/
@@ -210,7 +210,7 @@ public class CurvesTemporalMesh extends TemporalMesh {
}
/**
- * The method computes the value of a point at the certain relational distance from its beggining.
+ * The method computes the value of a point at the certain relational distance from its beginning.
* @param alongRatio
* the relative distance along the curve; should be a value between 0 and 1 inclusive;
* if the value exceeds the boundaries it is truncated to them
@@ -369,7 +369,7 @@ public class CurvesTemporalMesh extends TemporalMesh {
}
/**
- * The method loads the bevel object that sould be applied to curve. It can either be another curve or a generated one
+ * The method loads the bevel object that should be applied to curve. It can either be another curve or a generated one
* based on the bevel generating parameters in blender.
* @param curveStructure
* the structure with the curve's data (the curve being loaded, NOT the bevel curve)
@@ -707,7 +707,7 @@ public class CurvesTemporalMesh extends TemporalMesh {
/**
* the method applies scale for the given bevel points. The points table is
- * being modified so expect ypur result there.
+ * being modified so expect your result there.
*
* @param points
* the bevel points
@@ -726,7 +726,7 @@ public class CurvesTemporalMesh extends TemporalMesh {
/**
* A helper class that represents a single bezier line. It consists of Edge's and allows to
- * get a subline of a lentgh of the line.
+ * get a subline of a length of the line.
*
* @author Marcin Roguski (Kaelthas)
*/
@@ -776,7 +776,7 @@ public class CurvesTemporalMesh extends TemporalMesh {
}
if (cyclic) {
// if the first vertex is repeated at the end the distance will be = 0 so it won't affect the result, and if it is not repeated
- // then it is neccessary to add the length between the last and the first vertex
+ // then it is necessary to add the length between the last and the first vertex
length += vertices[vertices.length - 1].distance(vertices[0]);
}
}
@@ -834,7 +834,7 @@ public class CurvesTemporalMesh extends TemporalMesh {
}
/**
- * The method computes the value of a point at the certain relational distance from its beggining.
+ * The method computes the value of a point at the certain relational distance from its beginning.
* @param alongRatio
* the relative distance along the curve; should be a value between 0 and 1 inclusive;
* if the value exceeds the boundaries it is truncated to them
diff --git a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DnaBlockData.java b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DnaBlockData.java
index 35ffaa5db..9fae86160 100644
--- a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DnaBlockData.java
+++ b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DnaBlockData.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -85,7 +85,7 @@ public class DnaBlockData {
names[i] = inputStream.readString();
}
- // reding types
+ // reading types
inputStream.alignPosition(4);
identifier = inputStream.readByte() << 24 | inputStream.readByte() << 16 | inputStream.readByte() << 8 | inputStream.readByte();
if (identifier != TYPE_ID) {
@@ -181,7 +181,7 @@ public class DnaBlockData {
/**
* This method converts the given identifier code to string.
* @param code
- * the code taht is to be converted
+ * the code that is to be converted
* @return the string value of the identifier
*/
private String toString(int code) {
diff --git a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DynamicArray.java b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DynamicArray.java
index d6d110054..748757ab0 100644
--- a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DynamicArray.java
+++ b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/file/DynamicArray.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,7 +32,7 @@
package com.jme3.scene.plugins.blender.file;
/**
- * An array that can be dynamically modified/
+ * An array that can be dynamically modified
* @author Marcin Roguski
* @param
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class BulletAppState implements AppState, PhysicsTickListener {
+ /**
+ * true if-and-only-if the physics simulation is running (started but not
+ * yet stopped)
+ */
protected boolean initialized = false;
protected Application app;
+ /**
+ * manager that manages this state, set during attach
+ */
protected AppStateManager stateManager;
+ /**
+ * executor service for physics tasks, or null if parallel simulation is not
+ * running
+ */
protected ScheduledThreadPoolExecutor executor;
+ /**
+ * physics space managed by this state, or null if no simulation running
+ */
protected PhysicsSpace pSpace;
+ /**
+ * threading mode to use (not null)
+ */
protected ThreadingType threadingType = ThreadingType.SEQUENTIAL;
+ /**
+ * broadphase collision-detection algorithm for the physics space to use
+ * (not null)
+ */
protected BroadphaseType broadphaseType = BroadphaseType.DBVT;
+ /**
+ * minimum coordinate values for the physics space when using AXIS_SWEEP
+ * broadphase algorithms (not null)
+ */
protected Vector3f worldMin = new Vector3f(-10000f, -10000f, -10000f);
+ /**
+ * maximum coordinate values for the physics space when using AXIS_SWEEP
+ * broadphase algorithms (not null)
+ */
protected Vector3f worldMax = new Vector3f(10000f, 10000f, 10000f);
+ /**
+ * simulation speed multiplier (default=1, paused=0)
+ */
protected float speed = 1;
+ /**
+ * true if-and-only-if this state is enabled
+ */
protected boolean active = true;
+ /**
+ * true if-and-only-if debug visualization is enabled
+ */
protected boolean debugEnabled = false;
+ /**
+ * app state to manage the debug visualization, or null if none
+ */
protected BulletDebugAppState debugAppState;
+ /**
+ * time interval between frames (in seconds) from the most recent update
+ */
protected float tpf;
+ /**
+ * current physics task, or null if none
+ */
protected Future physicsFuture;
/**
- * Creates a new BulletAppState running a PhysicsSpace for physics
- * simulation, use getStateManager().addState(bulletAppState) to enable
- * physics for an Application.
+ * Instantiate an app state to manage a new PhysicsSpace with DBVT collision
+ * detection.
+ *
+ * Use getStateManager().addState(bulletAppState) to start physics.
*/
public BulletAppState() {
}
/**
- * Creates a new BulletAppState running a PhysicsSpace for physics
- * simulation, use getStateManager().addState(bulletAppState) to enable
- * physics for an Application.
+ * Instantiate an app state to manage a new PhysicsSpace.
+ *
+ * Use getStateManager().addState(bulletAppState) to start physics.
*
- * @param broadphaseType The type of broadphase collision detection,
- * BroadphaseType.DVBT is the default
+ * @param broadphaseType which broadphase collision-detection algorithm to
+ * use (not null)
*/
public BulletAppState(BroadphaseType broadphaseType) {
this(new Vector3f(-10000f, -10000f, -10000f), new Vector3f(10000f, 10000f, 10000f), broadphaseType);
}
/**
- * Creates a new BulletAppState running a PhysicsSpace for physics
- * simulation, use getStateManager().addState(bulletAppState) to enable
- * physics for an Application. An AxisSweep broadphase is used.
+ * Instantiate an app state to manage a new PhysicsSpace with AXIS_SWEEP_3
+ * collision detection.
+ *
+ * Use getStateManager().addState(bulletAppState) to start physics.
*
- * @param worldMin The minimum world extent
- * @param worldMax The maximum world extent
+ * @param worldMin the desired minimum coordinate values (not null,
+ * unaffected, default=-10k,-10k,-10k)
+ * @param worldMax the desired maximum coordinate values (not null,
+ * unaffected, default=10k,10k,10k)
*/
public BulletAppState(Vector3f worldMin, Vector3f worldMax) {
this(worldMin, worldMax, BroadphaseType.AXIS_SWEEP_3);
}
+ /**
+ * Instantiate an app state to manage a new PhysicsSpace.
+ *
+ * Use getStateManager().addState(bulletAppState) to enable physics.
+ *
+ * @param worldMin the desired minimum coordinate values (not null,
+ * unaffected, default=-10k,-10k,-10k)
+ * @param worldMax the desired maximum coordinate values (not null,
+ * unaffected, default=10k,10k,10k)
+ * @param broadphaseType which broadphase collision-detection algorithm to
+ * use (not null)
+ */
public BulletAppState(Vector3f worldMin, Vector3f worldMax, BroadphaseType broadphaseType) {
this.worldMin.set(worldMin);
this.worldMax.set(worldMax);
this.broadphaseType = broadphaseType;
}
+ /**
+ * Allocate the physics space and start physics for ThreadingType.PARALLEL.
+ *
+ * @return true if successful, otherwise false
+ */
private boolean startPhysicsOnExecutor() {
if (executor != null) {
executor.shutdown();
@@ -145,28 +215,49 @@ public class BulletAppState implements AppState, PhysicsTickListener {
}
};
+ /**
+ * Access the PhysicsSpace managed by this state. Normally there is none
+ * until the state is attached.
+ *
+ * @return the pre-existing instance, or null if no simulation running
+ */
public PhysicsSpace getPhysicsSpace() {
return pSpace;
}
/**
- * The physics system is started automatically on attaching, if you want to
- * start it before for some reason, you can use this method.
+ * Allocate a physics space and start physics.
+ *
+ * Physics starts automatically after the state is attached. To start it
+ * sooner, invoke this method.
*/
public void startPhysics() {
if (initialized) {
return;
}
- //start physics thread(pool)
- if (threadingType == ThreadingType.PARALLEL) {
- startPhysicsOnExecutor();
- } else {
- pSpace = new PhysicsSpace(worldMin, worldMax, broadphaseType);
+
+ switch (threadingType) {
+ case PARALLEL:
+ boolean success = startPhysicsOnExecutor();
+ assert success;
+ assert pSpace != null;
+ break;
+
+ case SEQUENTIAL:
+ pSpace = new PhysicsSpace(worldMin, worldMax, broadphaseType);
+ pSpace.addTickListener(this);
+ break;
+
+ default:
+ throw new IllegalStateException(threadingType.toString());
}
- pSpace.addTickListener(this);
+
initialized = true;
}
+ /**
+ * Stop physics after this state is detached.
+ */
public void stopPhysics() {
if(!initialized){
return;
@@ -180,32 +271,72 @@ public class BulletAppState implements AppState, PhysicsTickListener {
initialized = false;
}
+ /**
+ * Initialize this state prior to its 1st update. Should be invoked only by
+ * a subclass or by the AppStateManager.
+ *
+ * @param stateManager the manager for this state (not null)
+ * @param app the application which owns this state (not null)
+ */
public void initialize(AppStateManager stateManager, Application app) {
this.app = app;
this.stateManager = stateManager;
startPhysics();
}
+ /**
+ * Test whether the physics simulation is running (started but not yet
+ * stopped).
+ *
+ * @return true if running, otherwise false
+ */
public boolean isInitialized() {
return initialized;
}
+ /**
+ * Enable or disable this state.
+ *
+ * @param enabled true → enable, false → disable
+ */
public void setEnabled(boolean enabled) {
this.active = enabled;
}
+ /**
+ * Test whether this state is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean isEnabled() {
return active;
}
+ /**
+ * Alter whether debug visualization is enabled.
+ *
+ * @param debugEnabled true → enable, false → disable
+ */
public void setDebugEnabled(boolean debugEnabled) {
this.debugEnabled = debugEnabled;
}
+
+ /**
+ * Test whether debug visualization is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean isDebugEnabled() {
return debugEnabled;
}
+ /**
+ * Transition this state from detached to initializing. Should be invoked
+ * only by a subclass or by the AppStateManager.
+ *
+ * @param stateManager (not null)
+ */
public void stateAttached(AppStateManager stateManager) {
if (!initialized) {
startPhysics();
@@ -219,9 +350,22 @@ public class BulletAppState implements AppState, PhysicsTickListener {
}
}
+ /**
+ * Transition this state from running to terminating. Should be invoked only
+ * by a subclass or by the AppStateManager.
+ *
+ * @param stateManager (not null)
+ */
public void stateDetached(AppStateManager stateManager) {
}
+ /**
+ * Update this state prior to rendering. Should be invoked only by a
+ * subclass or by the AppStateManager. Invoked once per frame, provided the
+ * state is attached and enabled.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
public void update(float tpf) {
if (debugEnabled && debugAppState == null && pSpace != null) {
debugAppState = new BulletDebugAppState(pSpace);
@@ -237,6 +381,13 @@ public class BulletAppState implements AppState, PhysicsTickListener {
this.tpf = tpf;
}
+ /**
+ * Render this state. Should be invoked only by a subclass or by the
+ * AppStateManager. Invoked once per frame, provided the state is attached
+ * and enabled.
+ *
+ * @param rm the render manager (not null)
+ */
public void render(RenderManager rm) {
if (!active) {
return;
@@ -249,6 +400,11 @@ public class BulletAppState implements AppState, PhysicsTickListener {
}
}
+ /**
+ * Update this state after all rendering commands are flushed. Should be
+ * invoked only by a subclass or by the AppStateManager. Invoked once per
+ * frame, provided the state is attached and enabled.
+ */
public void postRender() {
if (physicsFuture != null) {
try {
@@ -262,6 +418,12 @@ public class BulletAppState implements AppState, PhysicsTickListener {
}
}
+ /**
+ * Transition this state from terminating to detached. Should be invoked
+ * only by a subclass or by the AppStateManager. Invoked once for each time
+ * {@link #initialize(com.jme3.app.state.AppStateManager, com.jme3.app.Application)}
+ * is invoked.
+ */
public void cleanup() {
if (debugAppState != null) {
stateManager.detach(debugAppState);
@@ -271,67 +433,106 @@ public class BulletAppState implements AppState, PhysicsTickListener {
}
/**
- * @return the threadingType
+ * Read which type of threading this app state uses.
+ *
+ * @return the threadingType (not null)
*/
public ThreadingType getThreadingType() {
return threadingType;
}
/**
- * Use before attaching state
+ * Alter which type of threading this app state uses. Not allowed after
+ * attaching the app state.
*
- * @param threadingType the threadingType to set
+ * @param threadingType the desired type (not null, default=SEQUENTIAL)
*/
public void setThreadingType(ThreadingType threadingType) {
this.threadingType = threadingType;
}
/**
- * Use before attaching state
+ * Alter the broadphase type the physics space will use. Not allowed after
+ * attaching the app state.
+ *
+ * @param broadphaseType an enum value (not null, default=DBVT)
*/
public void setBroadphaseType(BroadphaseType broadphaseType) {
this.broadphaseType = broadphaseType;
}
/**
- * Use before attaching state
+ * Alter the coordinate range. Not allowed after attaching the app state.
+ *
+ * @param worldMin the desired minimum coordinate values when using
+ * AXIS_SWEEP broadphase algorithms (not null, alias created,
+ * default=-10k,-10k,-10k)
*/
public void setWorldMin(Vector3f worldMin) {
this.worldMin = worldMin;
}
/**
- * Use before attaching state
+ * Alter the coordinate range. Not allowed after attaching the app state.
+ *
+ * @param worldMax the desired maximum coordinate values when using
+ * AXIS_SWEEP broadphase algorithms (not null, alias created,
+ * default=10k,10k,10k)
*/
public void setWorldMax(Vector3f worldMax) {
this.worldMax = worldMax;
}
+ /**
+ * Read the simulation speed.
+ *
+ * @return speed (≥0, default=1)
+ */
public float getSpeed() {
return speed;
}
+ /**
+ * Alter the simulation speed.
+ *
+ * @param speed the desired speed (≥0, default=1)
+ */
public void setSpeed(float speed) {
this.speed = speed;
}
-
+ /**
+ * Callback from Bullet, invoked just before the physics is stepped. A good
+ * time to clear/apply forces.
+ *
+ * @param space the space that is about to be stepped (not null)
+ * @param f the time per physics step (in seconds, ≥0)
+ */
public void prePhysicsTick(PhysicsSpace space, float f) {
}
+ /**
+ * Callback from Bullet, invoked just after the physics is stepped. A good
+ * time to clear/apply forces.
+ *
+ * @param space the space that is about to be stepped (not null)
+ * @param f the time per physics step (in seconds, ≥0)
+ */
public void physicsTick(PhysicsSpace space, float f) {
}
+ /**
+ * Enumerate threading modes.
+ */
public enum ThreadingType {
/**
- * Default mode; user update, physics update and rendering happen
- * sequentially (single threaded)
+ * Default mode: user update, physics update, and rendering happen
+ * sequentially. (single threaded)
*/
SEQUENTIAL,
/**
- * Parallel threaded mode; physics update and rendering are executed in
- * parallel, update order is kept.
+ * This interface is shared between JBullet and Native Bullet.
+ *
* @author normenhansen
*/
public interface PhysicsTickListener {
/**
- * Called before the physics is actually stepped, use to apply forces etc.
- * @param space the physics space
- * @param tpf the time per frame in seconds
+ * Callback from Bullet, invoked just before the physics is stepped. A good
+ * time to clear/apply forces.
+ *
+ * @param space the space that is about to be stepped (not null)
+ * @param tpf the time per physics step (in seconds, ≥0)
*/
public void prePhysicsTick(PhysicsSpace space, float tpf);
/**
- * Called after the physics has been stepped, use to check for forces etc.
- * @param space the physics space
- * @param tpf the time per frame in seconds
+ * Callback from Bullet, invoked just after the physics has been stepped,
+ * use to check for forces etc.
+ *
+ * @param space the space that was just stepped (not null)
+ * @param tpf the time per physics step (in seconds, ≥0)
*/
public void physicsTick(PhysicsSpace space, float tpf);
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionGroupListener.java b/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionGroupListener.java
index e50324116..4a7a0432d 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionGroupListener.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionGroupListener.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,18 +32,25 @@
package com.jme3.bullet.collision;
/**
+ * Interface to receive notifications whenever an object in a particular
+ * collision group is about to collide.
+ *
+ * This interface is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public interface PhysicsCollisionGroupListener {
/**
- * Called when two physics objects of the registered group are about to collide, called from physics thread.
+ * This interface is shared between JBullet and Native Bullet.
+ *
* @author normenhansen
*/
public interface PhysicsCollisionListener {
/**
- * Called when a collision happened in the PhysicsSpace, called from render thread.
- *
- * Do not store the event object as it will be cleared after the method has finished.
- * @param event the CollisionEvent
+ * Invoked when a collision happened in the PhysicsSpace. Invoked on the
+ * render thread.
+ *
+ * Do not retain the event object, as it will be reused after the
+ * collision() method returns. Copy any data you need during the collide()
+ * method.
+ *
+ * @param event the event that occurred (not null, reusable)
*/
public void collision(PhysicsCollisionEvent event);
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/collision/RagdollCollisionListener.java b/jme3-bullet/src/common/java/com/jme3/bullet/collision/RagdollCollisionListener.java
index cb00aeff3..84e50cdae 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/collision/RagdollCollisionListener.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/collision/RagdollCollisionListener.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -34,11 +34,22 @@ package com.jme3.bullet.collision;
import com.jme3.animation.Bone;
/**
+ * Interface to receive notifications whenever a KinematicRagdollControl
+ * collides with another physics object.
+ *
+ * This interface is shared between JBullet and Native Bullet.
*
* @author Nehon
*/
public interface RagdollCollisionListener {
+ /**
+ * Invoked when a collision involving a KinematicRagdollControl occurs.
+ *
+ * @param bone the ragdoll bone that collided (not null)
+ * @param object the collision object that collided with the bone (not null)
+ * @param event other event details (not null)
+ */
public void collide(Bone bone, PhysicsCollisionObject object, PhysicsCollisionEvent event);
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/collision/shapes/infos/ChildCollisionShape.java b/jme3-bullet/src/common/java/com/jme3/bullet/collision/shapes/infos/ChildCollisionShape.java
index ac7196258..1ca8bc37c 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/collision/shapes/infos/ChildCollisionShape.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/collision/shapes/infos/ChildCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -39,24 +39,56 @@ import com.jme3.math.Vector3f;
import java.io.IOException;
/**
+ * An element of a CompoundCollisionShape, consisting of a (non-compound) child
+ * shape, offset and rotated with respect to its parent.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class ChildCollisionShape implements Savable {
+ /**
+ * translation relative to parent shape (not null)
+ */
public Vector3f location;
+ /**
+ * rotation relative to parent shape (not null)
+ */
public Matrix3f rotation;
+ /**
+ * base shape (not null, not a compound shape)
+ */
public CollisionShape shape;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public ChildCollisionShape() {
}
+ /**
+ * Instantiate a child shape for use in a compound shape.
+ *
+ * @param location translation relative to the parent (not null, alias
+ * created)
+ * @param rotation rotation relative to the parent (not null, alias created)
+ * @param shape the base shape (not null, not a compound shape, alias
+ * created)
+ */
public ChildCollisionShape(Vector3f location, Matrix3f rotation, CollisionShape shape) {
this.location = location;
this.rotation = rotation;
this.shape = shape;
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
OutputCapsule capsule = ex.getCapsule(this);
capsule.write(location, "location", new Vector3f());
@@ -64,6 +96,12 @@ public class ChildCollisionShape implements Savable {
capsule.write(shape, "shape", new BoxCollisionShape(new Vector3f(1, 1, 1)));
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
InputCapsule capsule = im.getCapsule(this);
location = (Vector3f) capsule.readSavable("location", new Vector3f());
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/AbstractPhysicsControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/AbstractPhysicsControl.java
index d4f3658c0..f858d0e00 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/AbstractPhysicsControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/AbstractPhysicsControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -41,87 +41,119 @@ import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.Spatial;
+import com.jme3.scene.control.Control;
import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
import java.io.IOException;
/**
- * AbstractPhysicsControl manages the lifecycle of a physics object that is
- * attached to a spatial in the SceneGraph.
+ * Manage the life cycle of a physics object linked to a spatial in a scene
+ * graph.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public abstract class AbstractPhysicsControl implements PhysicsControl, JmeCloneable {
+ /**
+ * temporary storage during calculations
+ */
private final Quaternion tmp_inverseWorldRotation = new Quaternion();
+ /**
+ * spatial to which this control is added, or null if none
+ */
protected Spatial spatial;
+ /**
+ * true→control is enabled, false→control is disabled
+ */
protected boolean enabled = true;
+ /**
+ * true→body is added to the physics space, false→not added
+ */
protected boolean added = false;
+ /**
+ * space to which the physics object is (or would be) added
+ */
protected PhysicsSpace space = null;
+ /**
+ * true → physics coordinates match local transform, false →
+ * physics coordinates match world transform
+ */
protected boolean applyLocal = false;
/**
- * Called when the control is added to a new spatial, create any
- * spatial-dependent data here.
+ * Create spatial-dependent data. Invoked when this control is added to a
+ * spatial.
*
- * @param spat The new spatial, guaranteed not to be null
+ * @param spat the controlled spatial (not null)
*/
protected abstract void createSpatialData(Spatial spat);
/**
- * Called when the control is removed from a spatial, remove any
- * spatial-dependent data here.
+ * Destroy spatial-dependent data. Invoked when this control is removed from
+ * a spatial.
*
- * @param spat The old spatial, guaranteed not to be null
+ * @param spat the previously controlled spatial (not null)
*/
protected abstract void removeSpatialData(Spatial spat);
/**
- * Called when the physics object is supposed to move to the spatial
- * position.
+ * Translate the physics object to the specified location.
*
- * @param vec
+ * @param vec desired location (not null, unaffected)
*/
protected abstract void setPhysicsLocation(Vector3f vec);
/**
- * Called when the physics object is supposed to move to the spatial
- * rotation.
+ * Rotate the physics object to the specified orientation.
*
- * @param quat
+ * @param quat desired orientation (not null, unaffected)
*/
protected abstract void setPhysicsRotation(Quaternion quat);
/**
- * Called when the physics object is supposed to add all objects it needs to
- * manage to the physics space.
+ * Add all managed physics objects to the specified space.
*
- * @param space
+ * @param space which physics space to add to (not null)
*/
protected abstract void addPhysics(PhysicsSpace space);
/**
- * Called when the physics object is supposed to remove all objects added to
- * the physics space.
+ * Remove all managed physics objects from the specified space.
*
- * @param space
+ * @param space which physics space to remove from (not null)
*/
protected abstract void removePhysics(PhysicsSpace space);
+ /**
+ * Test whether physics-space coordinates should match the spatial's local
+ * coordinates.
+ *
+ * @return true if matching local coordinates, false if matching world
+ * coordinates
+ */
public boolean isApplyPhysicsLocal() {
return applyLocal;
}
/**
- * When set to true, the physics coordinates will be applied to the local
- * translation of the Spatial
+ * Alter whether physics-space coordinates should match the spatial's local
+ * coordinates.
*
- * @param applyPhysicsLocal
+ * @param applyPhysicsLocal true→match local coordinates,
+ * false→match world coordinates (default=false)
*/
public void setApplyPhysicsLocal(boolean applyPhysicsLocal) {
applyLocal = applyPhysicsLocal;
}
+ /**
+ * Access whichever spatial translation corresponds to the physics location.
+ *
+ * @return the pre-existing location vector (in physics-space coordinates,
+ * not null)
+ */
protected Vector3f getSpatialTranslation() {
if (applyLocal) {
return spatial.getLocalTranslation();
@@ -129,6 +161,12 @@ public abstract class AbstractPhysicsControl implements PhysicsControl, JmeClone
return spatial.getWorldTranslation();
}
+ /**
+ * Access whichever spatial rotation corresponds to the physics rotation.
+ *
+ * @return the pre-existing quaternion (in physics-space coordinates, not
+ * null)
+ */
protected Quaternion getSpatialRotation() {
if (applyLocal) {
return spatial.getLocalRotation();
@@ -137,10 +175,12 @@ public abstract class AbstractPhysicsControl implements PhysicsControl, JmeClone
}
/**
- * Applies a physics transform to the spatial
+ * Apply a physics transform to the spatial.
*
- * @param worldLocation
- * @param worldRotation
+ * @param worldLocation location vector (in physics-space coordinates, not
+ * null, unaffected)
+ * @param worldRotation orientation (in physics-space coordinates, not null,
+ * unaffected)
*/
protected void applyPhysicsTransform(Vector3f worldLocation, Quaternion worldRotation) {
if (enabled && spatial != null) {
@@ -162,13 +202,35 @@ public abstract class AbstractPhysicsControl implements PhysicsControl, JmeClone
}
}
-
- @Override
+
+ @Deprecated
+ @Override
+ public Control cloneForSpatial(Spatial spatial) {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Callback from {@link com.jme3.util.clone.Cloner} to convert this
+ * shallow-cloned control into a deep-cloned one, using the specified cloner
+ * and original to resolve copied fields.
+ *
+ * @param cloner the cloner that's cloning this control (not null)
+ * @param original the control from which this control was shallow-cloned
+ * (unused)
+ */
+ @Override
public void cloneFields( Cloner cloner, Object original ) {
this.spatial = cloner.clone(spatial);
createSpatialData(this.spatial);
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
public void setSpatial(Spatial spatial) {
if (this.spatial != null && this.spatial != spatial) {
removeSpatialData(this.spatial);
@@ -184,6 +246,15 @@ public abstract class AbstractPhysicsControl implements PhysicsControl, JmeClone
setPhysicsRotation(getSpatialRotation());
}
+ /**
+ * Enable or disable this control.
+ *
+ * When the control is disabled, the physics object is removed from physics
+ * space. When the control is enabled again, the physics object is moved to
+ * the spatial's location and then added to the physics space.
+ *
+ * @param enabled true→enable the control, false→disable it
+ */
public void setEnabled(boolean enabled) {
this.enabled = enabled;
if (space != null) {
@@ -201,6 +272,11 @@ public abstract class AbstractPhysicsControl implements PhysicsControl, JmeClone
}
}
+ /**
+ * Test whether this control is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean isEnabled() {
return enabled;
}
@@ -211,28 +287,48 @@ public abstract class AbstractPhysicsControl implements PhysicsControl, JmeClone
public void render(RenderManager rm, ViewPort vp) {
}
- public void setPhysicsSpace(PhysicsSpace space) {
- if (space == null) {
- if (this.space != null) {
- removePhysics(this.space);
- added = false;
- }
- } else {
- if (this.space == space) {
- return;
- } else if (this.space != null) {
- removePhysics(this.space);
- }
- addPhysics(space);
+ /**
+ * If enabled, add this control's physics object to the specified physics
+ * space. If not enabled, alter where the object would be added. The object
+ * is removed from any other space it's in.
+ *
+ * @param newSpace where to add, or null to simply remove
+ */
+ @Override
+ public void setPhysicsSpace(PhysicsSpace newSpace) {
+ if (space == newSpace) {
+ return;
+ }
+ if (added) {
+ removePhysics(space);
+ added = false;
+ }
+ if (newSpace != null && isEnabled()) {
+ addPhysics(newSpace);
added = true;
}
- this.space = space;
+ /*
+ * If this control isn't enabled, its physics object will be
+ * added to the new space when the control becomes enabled.
+ */
+ space = newSpace;
}
+ /**
+ * Access the physics space to which the object is (or would be) added.
+ *
+ * @return the pre-existing space, or null for none
+ */
public PhysicsSpace getPhysicsSpace() {
return space;
}
+ /**
+ * Serialize this object, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
OutputCapsule oc = ex.getCapsule(this);
@@ -241,6 +337,13 @@ public abstract class AbstractPhysicsControl implements PhysicsControl, JmeClone
oc.write(spatial, "spatial", null);
}
+ /**
+ * De-serialize this control from the specified importer, for example when
+ * loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
InputCapsule ic = im.getCapsule(this);
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/BetterCharacterControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/BetterCharacterControl.java
index 30190f1f1..027d00f33 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/BetterCharacterControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/BetterCharacterControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -48,9 +48,7 @@ import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.Spatial;
-import com.jme3.scene.control.Control;
import com.jme3.util.TempVars;
-import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
import java.io.IOException;
import java.util.List;
@@ -58,15 +56,18 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * This is intended to be a replacement for the internal bullet character class.
- * A RigidBody with cylinder collision shape is used and its velocity is set
- * continuously, a ray test is used to check if the character is on the ground.
- *
- * The character keeps his own local coordinate system which adapts based on the
- * gravity working on the character so the character will always stand upright.
- *
- * Forces in the local x/z plane are dampened while those in the local y
- * direction are applied fully (e.g. jumping, falling).
+ * This class is intended to replace the CharacterControl class.
+ *
+ * A rigid body with cylinder collision shape is used and its velocity is set
+ * continuously. A ray test is used to test whether the character is on the
+ * ground.
+ *
+ * The character keeps their own local coordinate system which adapts based on
+ * the gravity working on the character so they will always stand upright.
+ *
+ * Motion in the local X-Z plane is damped.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
@@ -76,10 +77,16 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
protected PhysicsRigidBody rigidBody;
protected float radius;
protected float height;
+ /**
+ * mass of this character (>0)
+ */
protected float mass;
+ /**
+ * relative height when ducked (1=full height)
+ */
protected float duckedFactor = 0.6f;
/**
- * Local up direction, derived from gravity.
+ * local up direction, derived from gravity
*/
protected final Vector3f localUp = new Vector3f(0, 1, 0);
/**
@@ -96,22 +103,27 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
*/
protected final Quaternion localForwardRotation = new Quaternion(Quaternion.DIRECTION_Z);
/**
- * Is a z-forward vector based on the view direction and the current local
- * x/z plane.
+ * a Z-forward vector based on the view direction and the local X-Z plane.
*/
protected final Vector3f viewDirection = new Vector3f(0, 0, 1);
/**
- * Stores final spatial location, corresponds to RigidBody location.
+ * spatial location, corresponds to RigidBody location.
*/
protected final Vector3f location = new Vector3f();
/**
- * Stores final spatial rotation, is a z-forward rotation based on the view
- * direction and the current local x/z plane. See also rotatedViewDirection.
+ * spatial rotation, a Z-forward rotation based on the view direction and
+ * local X-Z plane.
+ *
+ * @see #rotatedViewDirection
*/
protected final Quaternion rotation = new Quaternion(Quaternion.DIRECTION_Z);
protected final Vector3f rotatedViewDirection = new Vector3f(0, 0, 1);
protected final Vector3f walkDirection = new Vector3f();
protected final Vector3f jumpForce;
+ /**
+ * X-Z motion damping factor (0→no damping, 1=no external forces,
+ * default=0.9)
+ */
protected float physicsDamping = 0.9f;
protected final Vector3f scale = new Vector3f(1, 1, 1);
protected final Vector3f velocity = new Vector3f();
@@ -121,20 +133,23 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
protected boolean wantToUnDuck = false;
/**
- * Only used for serialization, do not use this constructor.
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
*/
public BetterCharacterControl() {
jumpForce = new Vector3f();
}
/**
- * Creates a new character with the given properties. Note that to avoid
- * issues the final height when ducking should be larger than 2x radius. The
- * jumpForce will be set to an upwards force of 5x mass.
+ * Instantiate an enabled control with the specified properties.
+ *
+ * The final height when ducking must be larger than 2x radius. The
+ * jumpForce will be set to an upward force of 5x mass.
*
- * @param radius
- * @param height
- * @param mass
+ * @param radius the radius of the character's collision shape (>0)
+ * @param height the height of the character's collision shape
+ * (>2*radius)
+ * @param mass the character's mass (≥0)
*/
public BetterCharacterControl(float radius, float height, float mass) {
this.radius = radius;
@@ -145,6 +160,13 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
rigidBody.setAngularFactor(0);
}
+ /**
+ * Update this control. Invoked once per frame during the logical-state
+ * update, provided the control is added to a scene graph. Do not invoke
+ * directly from user code.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
@Override
public void update(float tpf) {
super.update(tpf);
@@ -153,16 +175,24 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
applyPhysicsTransform(location, rotation);
}
+ /**
+ * Render this control. Invoked once per view port per frame, provided the
+ * control is added to a scene. Should be invoked only by a subclass or by
+ * the RenderManager.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
@Override
public void render(RenderManager rm, ViewPort vp) {
super.render(rm, vp);
}
/**
- * Used internally, don't call manually
+ * Callback from Bullet, invoked just before the physics is stepped.
*
- * @param space
- * @param tpf
+ * @param space the space that is about to be stepped (not null)
+ * @param tpf the time per physics step (in seconds, ≥0)
*/
public void prePhysicsTick(PhysicsSpace space, float tpf) {
checkOnGround();
@@ -174,8 +204,8 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
TempVars vars = TempVars.get();
Vector3f currentVelocity = vars.vect2.set(velocity);
-
- // dampen existing x/z forces
+
+ // Attenuate any existing X-Z motion.
float existingLeftVelocity = velocity.dot(localLeft);
float existingForwardVelocity = velocity.dot(localForward);
Vector3f counter = vars.vect1;
@@ -210,20 +240,20 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Used internally, don't call manually
+ * Callback from Bullet, invoked just after the physics has been stepped.
*
- * @param space
- * @param tpf
+ * @param space the space that was just stepped (not null)
+ * @param tpf the time per physics step (in seconds, ≥0)
*/
public void physicsTick(PhysicsSpace space, float tpf) {
rigidBody.getLinearVelocity(velocity);
}
/**
- * Move the character somewhere. Note the character also takes the location
- * of any spatial its being attached to in the moment it is attached.
+ * Move the character somewhere. Note the character also warps to the
+ * location of the spatial when the control is added.
*
- * @param vec The new character location.
+ * @param vec the desired character location (not null)
*/
public void warp(Vector3f vec) {
setPhysicsLocation(vec);
@@ -241,32 +271,32 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Set the jump force as a Vector3f. The jump force is local to the
- * characters coordinate system, which normally is always z-forward (in
- * world coordinates, parent coordinates when set to applyLocalPhysics)
+ * Alter the jump force. The jump force is local to the character's
+ * coordinate system, which normally is always z-forward (in world
+ * coordinates, parent coordinates when set to applyLocalPhysics)
*
- * @param jumpForce The new jump force
+ * @param jumpForce the desired jump force (not null, unaffected,
+ * default=5*mass in +Y direction)
*/
public void setJumpForce(Vector3f jumpForce) {
this.jumpForce.set(jumpForce);
}
/**
- * Gets the current jump force. The default is 5 * character mass in y
- * direction.
+ * Access the jump force.
*
- * @return
+ * @return the pre-existing vector (not null)
*/
public Vector3f getJumpForce() {
return jumpForce;
}
/**
- * Check if the character is on the ground. This is determined by a ray test
- * in the center of the character and might return false even if the
- * character is not falling yet.
+ * Test whether the character is supported. Uses a ray test from the center
+ * of the character and might return false even if the character is not
+ * falling yet.
*
- * @return
+ * @return true if on the ground, otherwise false
*/
public boolean isOnGround() {
return onGround;
@@ -276,10 +306,10 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
* Toggle character ducking. When ducked the characters capsule collision
* shape height will be multiplied by duckedFactor to make the capsule
* smaller. When unducking, the character will check with a ray test if it
- * can in fact unduck and only do so when its possible. You can check the
- * state of the unducking by checking isDucked().
+ * can in fact unduck and only do so when its possible. You can test the
+ * state using isDucked().
*
- * @param enabled
+ * @param enabled true→duck, false→unduck
*/
public void setDucked(boolean enabled) {
if (enabled) {
@@ -300,33 +330,33 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
* Check if the character is ducking, either due to user input or due to
* unducking being impossible at the moment (obstacle above).
*
- * @return
+ * @return true if ducking, otherwise false
*/
public boolean isDucked() {
return ducked;
}
/**
- * Sets the height multiplication factor for ducking.
+ * Alter the height multiplier for ducking.
*
- * @param factor The factor by which the height should be multiplied when
- * ducking
+ * @param factor the factor by which the height should be multiplied when
+ * ducking (≥0, ≤1)
*/
public void setDuckedFactor(float factor) {
duckedFactor = factor;
}
/**
- * Gets the height multiplication factor for ducking.
+ * Read the height multiplier for ducking.
*
- * @return
+ * @return the factor (≥0, ≤1)
*/
public float getDuckedFactor() {
return duckedFactor;
}
/**
- * Sets the walk direction of the character. This parameter is framerate
+ * Alter the character's the walk direction. This parameter is framerate
* independent and the character will move continuously in the direction
* given by the vector with the speed given by the vector length in m/s.
*
@@ -337,20 +367,19 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Gets the current walk direction and speed of the character. The length of
- * the vector defines the speed.
+ * Read the walk velocity. The length of the vector defines the speed.
*
- * @return
+ * @return the pre-existing vector (not null)
*/
public Vector3f getWalkDirection() {
return walkDirection;
}
/**
- * Sets the view direction for the character. Note this only defines the
- * rotation of the spatial in the local x/z plane of the character.
+ * Alter the character's view direction. Note this only defines the
+ * orientation in the local X-Z plane.
*
- * @param vec
+ * @param vec a direction vector (not null, unaffected)
*/
public void setViewDirection(Vector3f vec) {
viewDirection.set(vec);
@@ -358,10 +387,10 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Gets the current view direction, note this doesn't need to correspond
- * with the spatials forward direction.
+ * Access the view direction. This need not agree with the spatial's forward
+ * direction.
*
- * @return
+ * @return the pre-existing vector (not null)
*/
public Vector3f getViewDirection() {
return viewDirection;
@@ -369,15 +398,15 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
/**
* Realign the local forward vector to given direction vector, if null is
- * supplied Vector3f.UNIT_Z is used. Input vector has to be perpendicular to
- * current gravity vector. This normally only needs to be called when the
+ * supplied Vector3f.UNIT_Z is used. The input vector must be perpendicular
+ * to gravity vector. This normally only needs to be invoked when the
* gravity direction changed continuously and the local forward vector is
* off due to drift. E.g. after walking around on a sphere "planet" for a
- * while and then going back to a y-up coordinate system the local z-forward
- * might not be 100% alinged with Z axis.
+ * while and then going back to a Y-up coordinate system the local Z-forward
+ * might not be 100% aligned with the Z axis.
*
- * @param vec The new forward vector, has to be perpendicular to the current
- * gravity vector!
+ * @param vec the desired forward vector (perpendicular to the gravity
+ * vector, may be null, default=0,0,1)
*/
public void resetForward(Vector3f vec) {
if (vec == null) {
@@ -388,23 +417,21 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Get the current linear velocity along the three axes of the character.
- * This is prepresented in world coordinates, parent coordinates when the
- * control is set to applyLocalPhysics.
+ * Access the character's linear velocity in physics-space coordinates.
*
- * @return The current linear velocity of the character
+ * @return the pre-existing vector (not null)
*/
public Vector3f getVelocity() {
return velocity;
}
/**
- * Set the gravity for this character. Note that this also realigns the
- * local coordinate system of the character so that continuous changes in
- * gravity direction are possible while maintaining a sensible control over
- * the character.
+ * Alter the gravity acting on this character. Note that this also realigns
+ * the local coordinate system of the character so that continuous changes
+ * in gravity direction are possible while maintaining a sensible control
+ * over the character.
*
- * @param gravity
+ * @param gravity an acceleration vector (not null, unaffected)
*/
public void setGravity(Vector3f gravity) {
rigidBody.setGravity(gravity);
@@ -413,46 +440,48 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Get the current gravity of the character.
+ * Copy the character's gravity vector.
*
- * @return
+ * @return a new acceleration vector (not null)
*/
public Vector3f getGravity() {
return rigidBody.getGravity();
}
/**
- * Get the current gravity of the character.
+ * Copy the character's gravity vector.
*
- * @param store The vector to store the result in
- * @return
+ * @param store storage for the result (modified if not null)
+ * @return an acceleration vector (either the provided storage or a new
+ * vector, not null)
*/
public Vector3f getGravity(Vector3f store) {
return rigidBody.getGravity(store);
}
/**
- * Sets how much the physics forces in the local x/z plane should be
- * dampened.
- * @param physicsDamping The dampening value, 0 = no dampening, 1 = no external force, default = 0.9
+ * Alter how much motion in the local X-Z plane is damped.
+ *
+ * @param physicsDamping the desired damping factor (0→no damping, 1=no
+ * external forces, default=0.9)
*/
public void setPhysicsDamping(float physicsDamping) {
this.physicsDamping = physicsDamping;
}
/**
- * Gets how much the physics forces in the local x/z plane should be
- * dampened.
+ * Read how much motion in the local X-Z plane is damped.
+ *
+ * @return the damping factor (0→no damping, 1=no external forces)
*/
public float getPhysicsDamping() {
return physicsDamping;
}
/**
- * This actually sets a new collision shape to the character to change the
- * height of the capsule.
+ * Alter the height of collision shape.
*
- * @param percent
+ * @param percent the desired height, as a percentage of the full height
*/
protected void setHeightPercent(float percent) {
scale.setY(percent);
@@ -460,7 +489,7 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * This checks if the character is on the ground by doing a ray test.
+ * Test whether the character is on the ground, by means of a ray test.
*/
protected void checkOnGround() {
TempVars vars = TempVars.get();
@@ -501,12 +530,10 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Gets a new collision shape based on the current scale parameter. The
- * created collisionshape is a capsule collision shape that is attached to a
- * compound collision shape with an offset to set the object center at the
- * bottom of the capsule.
+ * Create a collision shape based on the scale parameter. The new shape is a
+ * compound shape containing an offset capsule.
*
- * @return
+ * @return a new compound shape (not null)
*/
protected CollisionShape getShape() {
//TODO: cleanup size mess..
@@ -518,18 +545,18 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Gets the scaled height.
+ * Calculate the character's scaled height.
*
- * @return
+ * @return the height
*/
protected float getFinalHeight() {
return height * scale.getY();
}
/**
- * Gets the scaled radius.
+ * Calculate the character's scaled radius.
*
- * @return
+ * @return the radius
*/
protected float getFinalRadius() {
return radius * scale.getZ();
@@ -538,7 +565,7 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
/**
* Updates the local coordinate system from the localForward and localUp
* vectors, adapts localForward, sets localForwardRotation quaternion to
- * local z-forward rotation.
+ * local Z-forward rotation.
*/
protected void updateLocalCoordinateSystem() {
//gravity vector has possibly changed, calculate new world forward (UNIT_Z)
@@ -549,8 +576,8 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * Updates the local x/z-flattened view direction and the corresponding
- * rotation quaternion for the spatial.
+ * Updates the local X-Z view direction and the corresponding rotation
+ * quaternion for the spatial.
*/
protected void updateLocalViewDirection() {
//update local rotation quaternion to use for view rotation
@@ -570,7 +597,6 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
* set to the new direction
* @param worldUpVector The up vector to use, the result direction will be
* perpendicular to this
- * @return
*/
protected final void calculateNewForward(Quaternion rotation, Vector3f direction, Vector3f worldUpVector) {
if (direction == null) {
@@ -602,10 +628,9 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * This is implemented from AbstractPhysicsControl and called when the
- * spatial is attached for example.
+ * Translate the character to the specified location.
*
- * @param vec
+ * @param vec desired location (not null, unaffected)
*/
@Override
protected void setPhysicsLocation(Vector3f vec) {
@@ -614,12 +639,12 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * This is implemented from AbstractPhysicsControl and called when the
- * spatial is attached for example. We don't set the actual physics rotation
- * but the view rotation here. It might actually be altered by the
- * calculateNewForward method.
+ * Rotate the physics object to the specified orientation.
+ *
+ * We don't set the actual physics rotation but the view rotation here. It
+ * might actually be altered by the calculateNewForward method.
*
- * @param quat
+ * @param quat desired orientation (not null, unaffected)
*/
@Override
protected void setPhysicsRotation(Quaternion quat) {
@@ -629,10 +654,9 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * This is implemented from AbstractPhysicsControl and called when the
- * control is supposed to add all objects to the physics space.
+ * Add all managed physics objects to the specified space.
*
- * @param space
+ * @param space which physics space to add to (not null)
*/
@Override
protected void addPhysics(PhysicsSpace space) {
@@ -644,10 +668,9 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
}
/**
- * This is implemented from AbstractPhysicsControl and called when the
- * control is supposed to remove all objects from the physics space.
+ * Remove all managed physics objects from the specified space.
*
- * @param space
+ * @param space which physics space to remove from (not null)
*/
@Override
protected void removePhysics(PhysicsSpace space) {
@@ -655,23 +678,33 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
space.removeTickListener(this);
}
+ /**
+ * Create spatial-dependent data. Invoked when this control is added to a
+ * spatial.
+ *
+ * @param spat the controlled spatial (not null, alias created)
+ */
@Override
protected void createSpatialData(Spatial spat) {
rigidBody.setUserObject(spatial);
}
+ /**
+ * Destroy spatial-dependent data. Invoked when this control is removed from
+ * a spatial.
+ *
+ * @param spat the previously controlled spatial (not null)
+ */
@Override
protected void removeSpatialData(Spatial spat) {
rigidBody.setUserObject(null);
}
- @Override
- public Control cloneForSpatial(Spatial spatial) {
- BetterCharacterControl control = new BetterCharacterControl(radius, height, mass);
- control.setJumpForce(jumpForce);
- return control;
- }
-
+ /**
+ * Create a shallow clone for the JME cloner.
+ *
+ * @return a new control (not null)
+ */
@Override
public Object jmeClone() {
BetterCharacterControl control = new BetterCharacterControl(radius, height, mass);
@@ -680,6 +713,12 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
return control;
}
+ /**
+ * Serialize this control, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -691,6 +730,12 @@ public class BetterCharacterControl extends AbstractPhysicsControl implements Ph
oc.write(physicsDamping, "physicsDamping", 0.9f);
}
+ /**
+ * De-serialize this control, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/CharacterControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/CharacterControl.java
index d12e5991a..e34b5b3b6 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/CharacterControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/CharacterControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -89,21 +89,10 @@ public class CharacterControl extends PhysicsCharacter implements PhysicsControl
return spatial.getWorldTranslation();
}
+ @Deprecated
@Override
public Control cloneForSpatial(Spatial spatial) {
- CharacterControl control = new CharacterControl(collisionShape, stepHeight);
- control.setCcdMotionThreshold(getCcdMotionThreshold());
- control.setCcdSweptSphereRadius(getCcdSweptSphereRadius());
- control.setCollideWithGroups(getCollideWithGroups());
- control.setCollisionGroup(getCollisionGroup());
- control.setFallSpeed(getFallSpeed());
- control.setGravity(getGravity());
- control.setJumpSpeed(getJumpSpeed());
- control.setMaxSlope(getMaxSlope());
- control.setPhysicsLocation(getPhysicsLocation());
- control.setUpAxis(getUpAxis());
- control.setApplyPhysicsLocal(isApplyPhysicsLocal());
- return control;
+ throw new UnsupportedOperationException();
}
@Override
@@ -113,6 +102,7 @@ public class CharacterControl extends PhysicsCharacter implements PhysicsControl
control.setCcdSweptSphereRadius(getCcdSweptSphereRadius());
control.setCollideWithGroups(getCollideWithGroups());
control.setCollisionGroup(getCollisionGroup());
+ control.setContactResponse(isContactResponse());
control.setFallSpeed(getFallSpeed());
control.setGravity(getGravity());
control.setJumpSpeed(getJumpSpeed());
@@ -201,21 +191,31 @@ public class CharacterControl extends PhysicsCharacter implements PhysicsControl
public void render(RenderManager rm, ViewPort vp) {
}
- public void setPhysicsSpace(PhysicsSpace space) {
- if (space == null) {
- if (this.space != null) {
- this.space.removeCollisionObject(this);
- added = false;
- }
- } else {
- if(this.space == space) return;
- // if this object isn't enabled, it will be added when it will be enabled.
- if (isEnabled()) {
- space.addCollisionObject(this);
- added = true;
- }
+ /**
+ * If enabled, add this control's physics object to the specified physics
+ * space. If not enabled, alter where the object would be added. The object
+ * is removed from any other space it's currently in.
+ *
+ * @param newSpace where to add, or null to simply remove
+ */
+ @Override
+ public void setPhysicsSpace(PhysicsSpace newSpace) {
+ if (space == newSpace) {
+ return;
+ }
+ if (added) {
+ space.removeCollisionObject(this);
+ added = false;
+ }
+ if (newSpace != null && isEnabled()) {
+ newSpace.addCollisionObject(this);
+ added = true;
}
- this.space = space;
+ /*
+ * If this control isn't enabled, its physics object will be
+ * added to the new space when the control becomes enabled.
+ */
+ space = newSpace;
}
public PhysicsSpace getPhysicsSpace() {
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/GhostControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/GhostControl.java
index 70c636507..7ff51670d 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/GhostControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/GhostControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -49,38 +49,82 @@ import com.jme3.util.clone.JmeCloneable;
import java.io.IOException;
/**
- * A GhostControl moves with the spatial it is attached to and can be used to check
- * overlaps with other physics objects (e.g. aggro radius).
+ * A physics control to link a PhysicsGhostObject to a spatial.
+ *
+ * The ghost object moves with the spatial it is attached to and can be used to
+ * detect overlaps with other physics objects (e.g. aggro radius).
+ *
+ * This class is shared between JBullet and Native Bullet.
+ *
* @author normenhansen
*/
public class GhostControl extends PhysicsGhostObject implements PhysicsControl, JmeCloneable {
+ /**
+ * spatial to which this control is added, or null if none
+ */
protected Spatial spatial;
+ /**
+ * true→control is enabled, false→control is disabled
+ */
protected boolean enabled = true;
+ /**
+ * true→body is added to the physics space, false→not added
+ */
protected boolean added = false;
+ /**
+ * space to which the ghost object is (or would be) added
+ */
protected PhysicsSpace space = null;
+ /**
+ * true → physics coordinates match local transform, false →
+ * physics coordinates match world transform
+ */
protected boolean applyLocal = false;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public GhostControl() {
}
+ /**
+ * Instantiate an enabled control with the specified shape.
+ *
+ * @param shape (not null)
+ */
public GhostControl(CollisionShape shape) {
super(shape);
}
+ /**
+ * Test whether physics-space coordinates should match the spatial's local
+ * coordinates.
+ *
+ * @return true if matching local coordinates, false if matching world
+ * coordinates
+ */
public boolean isApplyPhysicsLocal() {
return applyLocal;
}
/**
- * When set to true, the physics coordinates will be applied to the local
- * translation of the Spatial
- * @param applyPhysicsLocal
+ * Alter whether physics-space coordinates should match the spatial's local
+ * coordinates.
+ *
+ * @param applyPhysicsLocal true→match local coordinates,
+ * false→match world coordinates (default=false)
*/
public void setApplyPhysicsLocal(boolean applyPhysicsLocal) {
applyLocal = applyPhysicsLocal;
}
+ /**
+ * Access whichever spatial translation corresponds to the physics location.
+ *
+ * @return the pre-existing vector (not null)
+ */
private Vector3f getSpatialTranslation() {
if (applyLocal) {
return spatial.getLocalTranslation();
@@ -88,6 +132,11 @@ public class GhostControl extends PhysicsGhostObject implements PhysicsControl,
return spatial.getWorldTranslation();
}
+ /**
+ * Access whichever spatial rotation corresponds to the physics rotation.
+ *
+ * @return the pre-existing quaternion (not null)
+ */
private Quaternion getSpatialRotation() {
if (applyLocal) {
return spatial.getLocalRotation();
@@ -95,20 +144,24 @@ public class GhostControl extends PhysicsGhostObject implements PhysicsControl,
return spatial.getWorldRotation();
}
+ /**
+ * Clone this control for a different spatial. No longer used as of JME 3.1.
+ *
+ * @param spatial the spatial for the clone to control (or null)
+ * @return a new control (not null)
+ */
+ @Deprecated
@Override
public Control cloneForSpatial(Spatial spatial) {
- GhostControl control = new GhostControl(collisionShape);
- control.setCcdMotionThreshold(getCcdMotionThreshold());
- control.setCcdSweptSphereRadius(getCcdSweptSphereRadius());
- control.setCollideWithGroups(getCollideWithGroups());
- control.setCollisionGroup(getCollisionGroup());
- control.setPhysicsLocation(getPhysicsLocation());
- control.setPhysicsRotation(getPhysicsRotationMatrix());
- control.setApplyPhysicsLocal(isApplyPhysicsLocal());
- return control;
+ throw new UnsupportedOperationException();
}
- @Override
+ /**
+ * Create a shallow clone for the JME cloner.
+ *
+ * @return a new control (not null)
+ */
+ @Override
public Object jmeClone() {
GhostControl control = new GhostControl(collisionShape);
control.setCcdMotionThreshold(getCcdMotionThreshold());
@@ -122,11 +175,27 @@ public class GhostControl extends PhysicsGhostObject implements PhysicsControl,
return control;
}
+ /**
+ * Callback from {@link com.jme3.util.clone.Cloner} to convert this
+ * shallow-cloned control into a deep-cloned one, using the specified cloner
+ * and original to resolve copied fields.
+ *
+ * @param cloner the cloner that's cloning this control (not null)
+ * @param original the control from which this control was shallow-cloned
+ * (unused)
+ */
@Override
public void cloneFields( Cloner cloner, Object original ) {
this.spatial = cloner.clone(spatial);
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
public void setSpatial(Spatial spatial) {
this.spatial = spatial;
setUserObject(spatial);
@@ -137,6 +206,15 @@ public class GhostControl extends PhysicsGhostObject implements PhysicsControl,
setPhysicsRotation(getSpatialRotation());
}
+ /**
+ * Enable or disable this control.
+ *
+ * When the control is disabled, the ghost object is removed from physics
+ * space. When the control is enabled again, the object is moved to the
+ * current location of the spatial and then added to the physics space.
+ *
+ * @param enabled true→enable the control, false→disable it
+ */
public void setEnabled(boolean enabled) {
this.enabled = enabled;
if (space != null) {
@@ -154,10 +232,22 @@ public class GhostControl extends PhysicsGhostObject implements PhysicsControl,
}
}
+ /**
+ * Test whether this control is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean isEnabled() {
return enabled;
}
+ /**
+ * Update this control. Invoked once per frame during the logical-state
+ * update, provided the control is added to a scene. Do not invoke directly
+ * from user code.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
public void update(float tpf) {
if (!enabled) {
return;
@@ -166,29 +256,60 @@ public class GhostControl extends PhysicsGhostObject implements PhysicsControl,
setPhysicsRotation(getSpatialRotation());
}
+ /**
+ * Render this control. Invoked once per view port per frame, provided the
+ * control is added to a scene. Should be invoked only by a subclass or by
+ * the RenderManager.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
public void render(RenderManager rm, ViewPort vp) {
}
- public void setPhysicsSpace(PhysicsSpace space) {
- if (space == null) {
- if (this.space != null) {
- this.space.removeCollisionObject(this);
- added = false;
- }
- } else {
- if (this.space == space) {
- return;
- }
- space.addCollisionObject(this);
+ /**
+ * If enabled, add this control's physics object to the specified physics
+ * space. If not enabled, alter where the object would be added. The object
+ * is removed from any other space it's currently in.
+ *
+ * @param newSpace where to add, or null to simply remove
+ */
+ @Override
+ public void setPhysicsSpace(PhysicsSpace newSpace) {
+ if (space == newSpace) {
+ return;
+ }
+ if (added) {
+ space.removeCollisionObject(this);
+ added = false;
+ }
+ if (newSpace != null && isEnabled()) {
+ newSpace.addCollisionObject(this);
added = true;
}
- this.space = space;
+ /*
+ * If this control isn't enabled, its physics object will be
+ * added to the new space when the control becomes enabled.
+ */
+ space = newSpace;
}
+ /**
+ * Access the physics space to which the ghost object is (or would be)
+ * added.
+ *
+ * @return the pre-existing space, or null for none
+ */
public PhysicsSpace getPhysicsSpace() {
return space;
}
+ /**
+ * Serialize this control, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -198,6 +319,12 @@ public class GhostControl extends PhysicsGhostObject implements PhysicsControl,
oc.write(spatial, "spatial", null);
}
+ /**
+ * De-serialize this control, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/KinematicRagdollControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/KinematicRagdollControl.java
index 6c25b6662..8a99ddc22 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/KinematicRagdollControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/KinematicRagdollControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -31,37 +31,22 @@
*/
package com.jme3.bullet.control;
-import com.jme3.animation.AnimControl;
-import com.jme3.animation.Bone;
-import com.jme3.animation.Skeleton;
-import com.jme3.animation.SkeletonControl;
+import com.jme3.animation.*;
import com.jme3.bullet.PhysicsSpace;
-import com.jme3.bullet.collision.PhysicsCollisionEvent;
-import com.jme3.bullet.collision.PhysicsCollisionListener;
-import com.jme3.bullet.collision.PhysicsCollisionObject;
-import com.jme3.bullet.collision.RagdollCollisionListener;
+import com.jme3.bullet.collision.*;
import com.jme3.bullet.collision.shapes.BoxCollisionShape;
import com.jme3.bullet.collision.shapes.HullCollisionShape;
-import com.jme3.bullet.control.ragdoll.HumanoidRagdollPreset;
-import com.jme3.bullet.control.ragdoll.RagdollPreset;
-import com.jme3.bullet.control.ragdoll.RagdollUtils;
+import com.jme3.bullet.control.ragdoll.*;
import com.jme3.bullet.joints.SixDofJoint;
import com.jme3.bullet.objects.PhysicsRigidBody;
-import com.jme3.export.InputCapsule;
-import com.jme3.export.JmeExporter;
-import com.jme3.export.JmeImporter;
-import com.jme3.export.OutputCapsule;
-import com.jme3.export.Savable;
-import com.jme3.math.FastMath;
-import com.jme3.math.Quaternion;
-import com.jme3.math.Vector3f;
+import com.jme3.export.*;
+import com.jme3.math.*;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
+import com.jme3.scene.Mesh;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
-import com.jme3.scene.control.Control;
import com.jme3.util.TempVars;
-import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
import java.io.IOException;
import java.util.*;
@@ -73,29 +58,39 @@ import java.util.logging.Logger;
* use this control you need a model with an AnimControl and a
* SkeletonControl. This control creates collision
- * shapes for each bones of the skeleton when you call
- * spatial.addControl(ragdollControl). multLocal
multiplies a provided vector to this vector
+ * multLocal
multiplies a provided vector by this vector
* internally, and returns a handle to this vector for easy chaining of
* calls. If the provided vector is null, null is returned.
*
* @param vec
- * the vector to mult to this vector.
+ * the vector to multiply by this vector.
* @return this
*/
public Vector3d multLocal(Vector3d vec) {
@@ -522,7 +522,7 @@ public final class Vector3d implements Savable, Cloneable, Serializable {
}
/**
- * multLocal
multiplies a provided vector to this vector
+ * multLocal
multiplies a provided vector by this vector
* internally, and returns a handle to this vector for easy chaining of
* calls. If the provided vector is null, null is returned.
*
@@ -539,7 +539,7 @@ public final class Vector3d implements Savable, Cloneable, Serializable {
}
/**
- * multLocal
multiplies a provided vector to this vector
+ * multLocal
multiplies a provided vector by this vector
* internally, and returns a handle to this vector for easy chaining of
* calls. If the provided vector is null, null is returned.
*
@@ -657,7 +657,7 @@ public final class Vector3d implements Savable, Cloneable, Serializable {
}
/**
- * subtractLocal
subtracts a provided vector to this vector
+ * subtractLocal
subtracts a provided vector from this vector
* internally, and returns a handle to this vector for easy chaining of
* calls. If the provided vector is null, null is returned.
*
@@ -825,7 +825,7 @@ public final class Vector3d implements Savable, Cloneable, Serializable {
/**
* hashCode
returns a unique code for this vector object based
- * on it's values. If two vectors are logically equivalent, they will return
+ * on its values. If two vectors are logically equivalent, they will return
* the same hash code value.
* @return the hash code value of this vector.
*/
diff --git a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/meshes/MeshHelper.java b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/meshes/MeshHelper.java
index 49482c87f..4fcab8723 100644
--- a/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/meshes/MeshHelper.java
+++ b/jme3-blender/src/main/java/com/jme3/scene/plugins/blender/meshes/MeshHelper.java
@@ -291,27 +291,30 @@ public class MeshHelper extends AbstractBlenderHelper {
Structure defbase = (Structure) parent.getFieldValue("defbase");
ListBulletAppState
allows using bullet physics in an Application.
+ * An app state to manage a single Bullet physics space.
+ *
Multiple BulletAppStates will
- * execute in parallel in this mode.
+ * Parallel threaded mode: physics update and rendering are executed in
+ * parallel, update order is maintained.
*/
PARALLEL,
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/PhysicsTickListener.java b/jme3-bullet/src/common/java/com/jme3/bullet/PhysicsTickListener.java
index 0a52a5119..7bbd704aa 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/PhysicsTickListener.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/PhysicsTickListener.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,22 +32,29 @@
package com.jme3.bullet;
/**
- * Implement this interface to be called from the physics thread on a physics update.
+ * Callback interface from the physics thread, used to clear/apply forces.
+ *
- * This is only called when the collision will happen based on the collisionGroup and collideWithGroups
- * settings in the PhysicsCollisionObject. That is the case when one of the partys has the
- * collisionGroup of the other in its collideWithGroups set.
- * @param nodeA CollisionObject #1
- * @param nodeB CollisionObject #2
+ * Invoked when two physics objects of the registered group are about to
+ * collide. invoked on the physics thread.
+ * This is only invoked when the collision will happen based on the
+ * collisionGroup and collideWithGroups settings in the
+ * PhysicsCollisionObject. That is the case when one of the parties
+ * has the collisionGroup of the other in its collideWithGroups set.
+ *
+ * @param nodeA collision object #1
+ * @param nodeB collision object #2
* @return true if the collision should happen, false otherwise
*/
public boolean collide(PhysicsCollisionObject nodeA, PhysicsCollisionObject nodeB);
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionListener.java b/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionListener.java
index b49e3627f..8bcaf4e22 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionListener.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/collision/PhysicsCollisionListener.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,16 +32,24 @@
package com.jme3.bullet.collision;
/**
- * Interface for Objects that want to be informed about collision events in the physics space
+ * Interface to receive notifications whenever an object in a particular physics
+ * space collides.
+ *
This should be the case if you imported an animated
* model from Ogre or blender.
Note enabling/disabling the control
- * add/removes it from the physic space
By using this method, bone that are not used to create
- * a shape, are "merged" to their parent to create the collision shape.
There are 2 modes for this control :
+ * This control creates collision shapes for each bones of the skeleton when you + * invoke spatial.addControl(ragdollControl).
+ * There are 2 modes for this control :
+ * This class is shared between JBullet and Native Bullet.
*
- * @author Normen Hansen and Rémy Bouquet (Nehon)
+ * @author Normen Hansen and Rémy Bouquet (Nehon)
*/
+@Deprecated
public class KinematicRagdollControl extends AbstractPhysicsControl implements PhysicsCollisionListener, JmeCloneable {
+ /**
+ * list of registered collision listeners
+ */
protected static final Logger logger = Logger.getLogger(KinematicRagdollControl.class.getName());
protected List
+ * Not allowed after attaching the control.
*
- * @param name
+ * @param name the name of the bone to add
*/
public void addBoneName(String name) {
boneList.add(name);
}
+ /**
+ * Generate physics shapes and bone links for the skeleton.
+ *
+ * @param model the spatial with the model's SkeletonControl (not null)
+ */
protected void scanSpatial(Spatial model) {
AnimControl animControl = model.getControl(AnimControl.class);
Map
+ * This interface is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public interface PhysicsControl extends Control {
/**
- * Only used internally, do not call.
- * @param space
+ * If enabled, add this control's physics object to the specified physics
+ * space. In not enabled, alter where the object would be added. The object
+ * is removed from any other space it's currently in.
+ *
+ * @param space where to add, or null to simply remove
*/
public void setPhysicsSpace(PhysicsSpace space);
+ /**
+ * Access the physics space to which the object is (or would be) added.
+ *
+ * @return the pre-existing space, or null for none
+ */
public PhysicsSpace getPhysicsSpace();
/**
- * The physics object is removed from the physics space when the control
- * is disabled. When the control is enabled again the physics object is
- * moved to the current location of the spatial and then added to the physics
- * space. This allows disabling/enabling physics to move the spatial freely.
- * @param state
+ * Enable or disable this control.
+ *
+ * The physics object is removed from its physics space when the control is
+ * disabled. When the control is enabled again, the physics object is moved
+ * to the current location of the spatial and then added to the physics
+ * space.
+ *
+ * @param state true→enable the control, false→disable it
*/
public void setEnabled(boolean state);
/**
- * Returns the current enabled state of the physics control
- * @return current enabled state
+ * Test whether this control is enabled.
+ *
+ * @return true if enabled, otherwise false
*/
public boolean isEnabled();
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/RigidBodyControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/RigidBodyControl.java
index f2002be02..4094ab4db 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/RigidBodyControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/RigidBodyControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -53,72 +53,94 @@ import com.jme3.scene.shape.Box;
import com.jme3.scene.shape.Sphere;
import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
-
import java.io.IOException;
/**
+ * A physics control to link a PhysicsRigidBody to a spatial.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl, JmeCloneable {
+ /**
+ * spatial to which this control is added, or null if none
+ */
protected Spatial spatial;
+ /**
+ * true→control is enabled, false→control is disabled
+ */
protected boolean enabled = true;
+ /**
+ * true→body is added to the physics space, false→not added
+ */
protected boolean added = false;
+ /**
+ * space to which the body is (or would be) added
+ */
protected PhysicsSpace space = null;
+ /**
+ * true→body is kinematic, false→body is static or dynamic
+ */
protected boolean kinematicSpatial = true;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public RigidBodyControl() {
}
/**
- * When using this constructor, the CollisionShape for the RigidBody is generated
- * automatically when the Control is added to a Spatial.
- * @param mass When not 0, a HullCollisionShape is generated, otherwise a MeshCollisionShape is used. For geometries with box or sphere meshes the proper box or sphere collision shape is used.
+ * When using this constructor, the CollisionShape for the RigidBody is
+ * generated automatically when the control is added to a spatial.
+ *
+ * @param mass When not 0, a HullCollisionShape is generated, otherwise a
+ * MeshCollisionShape is used. For geometries with box or sphere meshes the
+ * proper box or sphere collision shape is used.
*/
public RigidBodyControl(float mass) {
this.mass = mass;
}
/**
- * Creates a new PhysicsNode with the supplied collision shape and mass 1
- * @param shape
+ * Instantiate an enabled control with mass=1 and the specified collision
+ * shape.
+ *
+ * @param shape the desired shape (not null, alias created)
*/
public RigidBodyControl(CollisionShape shape) {
super(shape);
}
+ /**
+ * Instantiate an enabled control with the specified collision shape and
+ * mass.
+ *
+ * @param shape the desired shape (not null, alias created)
+ * @param mass the desired mass (≥0)
+ */
public RigidBodyControl(CollisionShape shape, float mass) {
super(shape, mass);
}
+ /**
+ * Clone this control for a different spatial. No longer used as of JME 3.1.
+ *
+ * @param spatial the spatial for the clone to control (or null)
+ * @return a new control (not null)
+ */
@Override
public Control cloneForSpatial(Spatial spatial) {
- RigidBodyControl control = new RigidBodyControl(collisionShape, mass);
- control.setAngularFactor(getAngularFactor());
- control.setAngularSleepingThreshold(getAngularSleepingThreshold());
- control.setCcdMotionThreshold(getCcdMotionThreshold());
- control.setCcdSweptSphereRadius(getCcdSweptSphereRadius());
- control.setCollideWithGroups(getCollideWithGroups());
- control.setCollisionGroup(getCollisionGroup());
- control.setDamping(getLinearDamping(), getAngularDamping());
- control.setFriction(getFriction());
- control.setGravity(getGravity());
- control.setKinematic(isKinematic());
- control.setKinematicSpatial(isKinematicSpatial());
- control.setLinearSleepingThreshold(getLinearSleepingThreshold());
- control.setPhysicsLocation(getPhysicsLocation(null));
- control.setPhysicsRotation(getPhysicsRotationMatrix(null));
- control.setRestitution(getRestitution());
-
- if (mass > 0) {
- control.setAngularVelocity(getAngularVelocity());
- control.setLinearVelocity(getLinearVelocity());
- }
- control.setApplyPhysicsLocal(isApplyPhysicsLocal());
- return control;
+ throw new UnsupportedOperationException();
}
+ /**
+ * Create a shallow clone for the JME cloner.
+ *
+ * @return a new control (not null)
+ */
@Override
public Object jmeClone() {
RigidBodyControl control = new RigidBodyControl(collisionShape, mass);
@@ -128,6 +150,7 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
control.setCcdSweptSphereRadius(getCcdSweptSphereRadius());
control.setCollideWithGroups(getCollideWithGroups());
control.setCollisionGroup(getCollisionGroup());
+ control.setContactResponse(isContactResponse());
control.setDamping(getLinearDamping(), getAngularDamping());
control.setFriction(getFriction());
control.setGravity(getGravity());
@@ -149,11 +172,27 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
return control;
}
+ /**
+ * Callback from {@link com.jme3.util.clone.Cloner} to convert this
+ * shallow-cloned control into a deep-cloned one, using the specified cloner
+ * and original to resolve copied fields.
+ *
+ * @param cloner the cloner that's cloning this control (not null)
+ * @param original the control from which this control was shallow-cloned
+ * (unused)
+ */
@Override
public void cloneFields( Cloner cloner, Object original ) {
this.spatial = cloner.clone(spatial);
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
public void setSpatial(Spatial spatial) {
this.spatial = spatial;
setUserObject(spatial);
@@ -168,6 +207,10 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
setPhysicsRotation(getSpatialRotation());
}
+ /**
+ * Set the collision shape based on the controlled spatial and its
+ * descendents.
+ */
protected void createCollisionShape() {
if (spatial == null) {
return;
@@ -190,6 +233,15 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
}
}
+ /**
+ * Enable or disable this control.
+ *
+ * When the control is disabled, the body is removed from physics space.
+ * When the control is enabled again, the body is moved to the current
+ * location of the spatial and then added to the physics space.
+ *
+ * @param enabled true→enable the control, false→disable it
+ */
public void setEnabled(boolean enabled) {
this.enabled = enabled;
if (space != null) {
@@ -207,40 +259,62 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
}
}
+ /**
+ * Test whether this control is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean isEnabled() {
return enabled;
}
/**
- * Checks if this control is in kinematic spatial mode.
- * @return true if the spatial location is applied to this kinematic rigidbody
+ * Test whether this control is in kinematic mode.
+ *
+ * @return true if the spatial location and rotation are applied to the
+ * rigid body, otherwise false
*/
public boolean isKinematicSpatial() {
return kinematicSpatial;
}
/**
- * Sets this control to kinematic spatial mode so that the spatials transform will
- * be applied to the rigidbody in kinematic mode, defaults to true.
- * @param kinematicSpatial
+ * Enable or disable kinematic mode. In kinematic mode, the spatial's
+ * location and rotation will be applied to the rigid body.
+ *
+ * @param kinematicSpatial true→kinematic, false→dynamic or static
*/
public void setKinematicSpatial(boolean kinematicSpatial) {
this.kinematicSpatial = kinematicSpatial;
}
+ /**
+ * Test whether physics-space coordinates should match the spatial's local
+ * coordinates.
+ *
+ * @return true if matching local coordinates, false if matching world
+ * coordinates
+ */
public boolean isApplyPhysicsLocal() {
return motionState.isApplyPhysicsLocal();
}
/**
- * When set to true, the physics coordinates will be applied to the local
- * translation of the Spatial instead of the world translation.
- * @param applyPhysicsLocal
+ * Alter whether physics-space coordinates should match the spatial's local
+ * coordinates.
+ *
+ * @param applyPhysicsLocal true→match local coordinates,
+ * false→match world coordinates (default=false)
*/
public void setApplyPhysicsLocal(boolean applyPhysicsLocal) {
motionState.setApplyPhysicsLocal(applyPhysicsLocal);
}
+ /**
+ * Access whichever spatial translation corresponds to the physics location.
+ *
+ * @return the pre-existing vector (not null)
+ */
private Vector3f getSpatialTranslation(){
if(motionState.isApplyPhysicsLocal()){
return spatial.getLocalTranslation();
@@ -248,6 +322,11 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
return spatial.getWorldTranslation();
}
+ /**
+ * Access whichever spatial rotation corresponds to the physics rotation.
+ *
+ * @return the pre-existing quaternion (not null)
+ */
private Quaternion getSpatialRotation(){
if(motionState.isApplyPhysicsLocal()){
return spatial.getLocalRotation();
@@ -255,6 +334,12 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
return spatial.getWorldRotation();
}
+ /**
+ * Update this control. Invoked once per frame, during the logical-state
+ * update, provided the control is added to a scene.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
public void update(float tpf) {
if (enabled && spatial != null) {
if (isKinematic() && kinematicSpatial) {
@@ -266,30 +351,59 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
}
}
+ /**
+ * Render this control. Invoked once per view port per frame, provided the
+ * control is added to a scene. Should be invoked only by a subclass or by
+ * the RenderManager.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
public void render(RenderManager rm, ViewPort vp) {
}
- public void setPhysicsSpace(PhysicsSpace space) {
- if (space == null) {
- if (this.space != null) {
- this.space.removeCollisionObject(this);
- added = false;
- }
- } else {
- if (this.space == space) return;
- // if this object isn't enabled, it will be added when it will be enabled.
- if (isEnabled()) {
- space.addCollisionObject(this);
- added = true;
- }
+ /**
+ * If enabled, add this control's body to the specified physics space. In
+ * not enabled, alter where the body would be added. The body is removed
+ * from any other space it's currently in.
+ *
+ * @param newSpace where to add, or null to simply remove
+ */
+ @Override
+ public void setPhysicsSpace(PhysicsSpace newSpace) {
+ if (space == newSpace) {
+ return;
+ }
+ if (added) {
+ space.removeCollisionObject(this);
+ added = false;
}
- this.space = space;
+ if (newSpace != null && isEnabled()) {
+ newSpace.addCollisionObject(this);
+ added = true;
+ }
+ /*
+ * If this control isn't enabled, its body will be
+ * added to the new space when the control becomes enabled.
+ */
+ space = newSpace;
}
+ /**
+ * Access the physics space to which the body is (or would be) added.
+ *
+ * @return the pre-existing space, or null for none
+ */
public PhysicsSpace getPhysicsSpace() {
return space;
}
+ /**
+ * Serialize this control, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -300,6 +414,12 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
oc.write(spatial, "spatial", null);
}
+ /**
+ * De-serialize this control, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
@@ -310,4 +430,4 @@ public class RigidBodyControl extends PhysicsRigidBody implements PhysicsControl
motionState.setApplyPhysicsLocal(ic.readBoolean("applyLocalPhysics", false));
setUserObject(spatial);
}
-}
+}
\ No newline at end of file
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/VehicleControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/VehicleControl.java
index 5f6af8175..51210c6a7 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/VehicleControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/VehicleControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -43,7 +43,6 @@ import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
-import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
import com.jme3.scene.control.Control;
import com.jme3.util.clone.Cloner;
@@ -52,39 +51,75 @@ import java.io.IOException;
import java.util.Iterator;
/**
+ * A physics control to link a PhysicsVehicle to a spatial.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class VehicleControl extends PhysicsVehicle implements PhysicsControl, JmeCloneable {
+ /**
+ * spatial to which this control is added, or null if none
+ */
protected Spatial spatial;
+ /**
+ * true→control is enabled, false→control is disabled
+ */
protected boolean enabled = true;
+ /**
+ * space to which the vehicle is (or would be) added
+ */
protected PhysicsSpace space = null;
+ /**
+ * true→vehicle is added to the physics space, false→not added
+ */
protected boolean added = false;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public VehicleControl() {
}
/**
- * Creates a new PhysicsNode with the supplied collision shape
- * @param shape
+ * Instantiate an enabled control with mass=1 and the specified collision
+ * shape.
+ *
+ * @param shape the desired shape (not null, alias created)
*/
public VehicleControl(CollisionShape shape) {
super(shape);
}
+ /**
+ * Instantiate an enabled with the specified collision shape and mass.
+ *
+ * @param shape the desired shape (not null, alias created)
+ * @param mass (>0)
+ */
public VehicleControl(CollisionShape shape, float mass) {
super(shape, mass);
}
+ /**
+ * Test whether physics-space coordinates should match the spatial's local
+ * coordinates.
+ *
+ * @return true if matching local coordinates, false if matching world
+ * coordinates
+ */
public boolean isApplyPhysicsLocal() {
return motionState.isApplyPhysicsLocal();
}
/**
- * When set to true, the physics coordinates will be applied to the local
- * translation of the Spatial
- * @param applyPhysicsLocal
+ * Alter whether physics-space coordinates should match the spatial's local
+ * coordinates.
+ *
+ * @param applyPhysicsLocal true→match local coordinates,
+ * false→match world coordinates (default=false)
*/
public void setApplyPhysicsLocal(boolean applyPhysicsLocal) {
motionState.setApplyPhysicsLocal(applyPhysicsLocal);
@@ -108,57 +143,22 @@ public class VehicleControl extends PhysicsVehicle implements PhysicsControl, Jm
return spatial.getWorldRotation();
}
+ /**
+ * Clone this control for a different spatial. No longer used as of JME 3.1.
+ *
+ * @param spatial the spatial for the clone to control (or null)
+ * @return a new control (not null)
+ */
@Override
public Control cloneForSpatial(Spatial spatial) {
- VehicleControl control = new VehicleControl(collisionShape, mass);
- control.setAngularFactor(getAngularFactor());
- control.setAngularSleepingThreshold(getAngularSleepingThreshold());
- control.setAngularVelocity(getAngularVelocity());
- control.setCcdMotionThreshold(getCcdMotionThreshold());
- control.setCcdSweptSphereRadius(getCcdSweptSphereRadius());
- control.setCollideWithGroups(getCollideWithGroups());
- control.setCollisionGroup(getCollisionGroup());
- control.setDamping(getLinearDamping(), getAngularDamping());
- control.setFriction(getFriction());
- control.setGravity(getGravity());
- control.setKinematic(isKinematic());
- control.setLinearSleepingThreshold(getLinearSleepingThreshold());
- control.setLinearVelocity(getLinearVelocity());
- control.setPhysicsLocation(getPhysicsLocation());
- control.setPhysicsRotation(getPhysicsRotationMatrix());
- control.setRestitution(getRestitution());
-
- control.setFrictionSlip(getFrictionSlip());
- control.setMaxSuspensionTravelCm(getMaxSuspensionTravelCm());
- control.setSuspensionStiffness(getSuspensionStiffness());
- control.setSuspensionCompression(tuning.suspensionCompression);
- control.setSuspensionDamping(tuning.suspensionDamping);
- control.setMaxSuspensionForce(getMaxSuspensionForce());
-
- for (Iterator
+ * When the control is disabled, the vehicle is removed from physics space.
+ * When the control is enabled again, the physics object is moved to the
+ * spatial's location and then added to the physics space.
+ *
+ * @param enabled true→enable the control, false→disable it
+ */
public void setEnabled(boolean enabled) {
this.enabled = enabled;
if (space != null) {
@@ -243,10 +267,21 @@ public class VehicleControl extends PhysicsVehicle implements PhysicsControl, Jm
}
}
+ /**
+ * Test whether this control is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean isEnabled() {
return enabled;
}
+ /**
+ * Update this control. Invoked once per frame, during the logical-state
+ * update, provided the control is added to a scene.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
public void update(float tpf) {
if (enabled && spatial != null) {
if (getMotionState().applyTransform(spatial)) {
@@ -258,31 +293,59 @@ public class VehicleControl extends PhysicsVehicle implements PhysicsControl, Jm
}
}
+ /**
+ * Render this control. Invoked once per view port per frame, provided the
+ * control is added to a scene. Should be invoked only by a subclass or by
+ * the RenderManager.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
public void render(RenderManager rm, ViewPort vp) {
}
- public void setPhysicsSpace(PhysicsSpace space) {
- createVehicle(space);
- if (space == null) {
- if (this.space != null) {
- this.space.removeCollisionObject(this);
- added = false;
- }
- } else {
- if(this.space == space) return;
- // if this object isn't enabled, it will be added when it will be enabled.
- if (isEnabled()) {
- space.addCollisionObject(this);
- added = true;
- }
+ /**
+ * If enabled, add this control's physics object to the specified physics
+ * space. In not enabled, alter where the object would be added. The object
+ * is removed from any other space it's currently in.
+ *
+ * @param newSpace where to add, or null to simply remove
+ */
+ @Override
+ public void setPhysicsSpace(PhysicsSpace newSpace) {
+ if (space == newSpace) {
+ return;
}
- this.space = space;
+ if (added) {
+ space.removeCollisionObject(this);
+ added = false;
+ }
+ if (newSpace != null && isEnabled()) {
+ newSpace.addCollisionObject(this);
+ added = true;
+ }
+ /*
+ * If this control isn't enabled, its physics object will be
+ * added to the new space when the control becomes enabled.
+ */
+ space = newSpace;
}
+ /**
+ * Access the physics space to which the vehicle is (or would be) added.
+ *
+ * @return the pre-existing space, or null for none
+ */
public PhysicsSpace getPhysicsSpace() {
return space;
}
+ /**
+ * Serialize this control, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -292,6 +355,12 @@ public class VehicleControl extends PhysicsVehicle implements PhysicsControl, Jm
oc.write(spatial, "spatial", null);
}
+ /**
+ * De-serialize this control, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
@@ -301,4 +370,4 @@ public class VehicleControl extends PhysicsVehicle implements PhysicsControl, Jm
motionState.setApplyPhysicsLocal(ic.readBoolean("applyLocalPhysics", false));
setUserObject(spatial);
}
-}
+}
\ No newline at end of file
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/HumanoidRagdollPreset.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/HumanoidRagdollPreset.java
index cd9829e61..68696090e 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/HumanoidRagdollPreset.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/HumanoidRagdollPreset.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -34,11 +34,17 @@ package com.jme3.bullet.control.ragdoll;
import com.jme3.math.FastMath;
/**
+ * Example ragdoll presets for a typical humanoid skeleton.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author Nehon
*/
public class HumanoidRagdollPreset extends RagdollPreset {
+ /**
+ * Initialize the map from bone names to joint presets.
+ */
@Override
protected void initBoneMap() {
boneMap.put("head", new JointPreset(FastMath.QUARTER_PI, -FastMath.QUARTER_PI, FastMath.QUARTER_PI, -FastMath.QUARTER_PI, FastMath.QUARTER_PI, -FastMath.QUARTER_PI));
@@ -59,6 +65,9 @@ public class HumanoidRagdollPreset extends RagdollPreset {
}
+ /**
+ * Initialize the lexicon.
+ */
@Override
protected void initLexicon() {
LexiconEntry entry = new LexiconEntry();
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/RagdollPreset.java b/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/RagdollPreset.java
index ab0b3ef1a..637011c95 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/RagdollPreset.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/control/ragdoll/RagdollPreset.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -43,14 +43,35 @@ import java.util.logging.Logger;
*/
public abstract class RagdollPreset {
+ /**
+ * message logger for this class
+ */
protected static final Logger logger = Logger.getLogger(RagdollPreset.class.getName());
+ /**
+ * map bone names to joint presets
+ */
protected Map
+ * This class is shared between JBullet and Native Bullet.
*
* @author Nehon
*/
public class RagdollUtils {
+ /**
+ * A private constructor to inhibit instantiation of this class.
+ */
+ private RagdollUtils() {
+ }
+
+ /**
+ * Alter the limits of the specified 6-DOF joint.
+ *
+ * @param joint which joint to alter (not null)
+ * @param maxX the maximum rotation on the X axis (in radians)
+ * @param minX the minimum rotation on the X axis (in radians)
+ * @param maxY the maximum rotation on the Y axis (in radians)
+ * @param minY the minimum rotation on the Y axis (in radians)
+ * @param maxZ the maximum rotation on the Z axis (in radians)
+ * @param minZ the minimum rotation on the Z axis (in radians)
+ */
public static void setJointLimit(SixDofJoint joint, float maxX, float minX, float maxY, float minY, float maxZ, float minZ) {
joint.getRotationalLimitMotor(0).setHiLimit(maxX);
@@ -63,22 +82,21 @@ public class RagdollUtils {
joint.getRotationalLimitMotor(2).setLoLimit(minZ);
}
+ /**
+ * Build a map of mesh vertices in a subtree of the scene graph.
+ *
+ * @param model the root of the subtree (may be null)
+ * @return a new map (not null)
+ */
public static Map
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public abstract class AbstractPhysicsDebugControl extends AbstractControl {
private final Quaternion tmp_inverseWorldRotation = new Quaternion();
+ /**
+ * the app state that this control serves
+ */
protected final BulletDebugAppState debugAppState;
+ /**
+ * Instantiate an enabled control to serve the specified debug app state.
+ *
+ * @param debugAppState which app state (not null, alias created)
+ */
public AbstractPhysicsDebugControl(BulletDebugAppState debugAppState) {
this.debugAppState = debugAppState;
}
@@ -55,10 +68,27 @@ public abstract class AbstractPhysicsDebugControl extends AbstractControl {
@Override
protected abstract void controlUpdate(float tpf);
+ /**
+ * Apply the specified location and orientation to the controlled spatial.
+ *
+ * @param worldLocation location vector (in physics-space coordinates, not
+ * null, unaffected)
+ * @param worldRotation orientation (in physics-space coordinates, not null,
+ * unaffected)
+ */
protected void applyPhysicsTransform(Vector3f worldLocation, Quaternion worldRotation) {
applyPhysicsTransform(worldLocation, worldRotation, this.spatial);
}
+ /**
+ * Apply the specified location and orientation to the specified spatial.
+ *
+ * @param worldLocation location vector (in physics-space coordinates, not
+ * null, unaffected)
+ * @param worldRotation orientation (in physics-space coordinates, not null,
+ * unaffected)
+ * @param spatial where to apply (may be null)
+ */
protected void applyPhysicsTransform(Vector3f worldLocation, Quaternion worldRotation, Spatial spatial) {
if (spatial != null) {
Vector3f localLocation = spatial.getLocalTranslation();
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletCharacterDebugControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletCharacterDebugControl.java
index 43c1cfd36..514e79b16 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletCharacterDebugControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletCharacterDebugControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -42,25 +42,61 @@ import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
/**
+ * A physics-debug control used to visualize a PhysicsCharacter.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class BulletCharacterDebugControl extends AbstractPhysicsDebugControl {
+ /**
+ * character to visualize (not null)
+ */
protected final PhysicsCharacter body;
+ /**
+ * temporary storage for physics location
+ */
protected final Vector3f location = new Vector3f();
protected final Quaternion rotation = new Quaternion();
+ /**
+ * shape for which geom was generated
+ */
protected CollisionShape myShape;
+ /**
+ * geometry to visualize myShape (not null)
+ */
protected Spatial geom;
+ /**
+ * physics scale for which geom was generated
+ */
+ final private Vector3f oldScale = new Vector3f();
+
+ /**
+ * Instantiate an enabled control to visualize the specified character.
+ *
+ * @param debugAppState which app state (not null, alias created)
+ * @param body the character to visualize (not null, alias created)
+ */
public BulletCharacterDebugControl(BulletDebugAppState debugAppState, PhysicsCharacter body) {
super(debugAppState);
this.body = body;
myShape = body.getCollisionShape();
- this.geom = DebugShapeFactory.getDebugShape(body.getCollisionShape());
+ oldScale.set(myShape.getScale());
+
+ this.geom = DebugShapeFactory.getDebugShape(myShape);
+ this.geom.setName(body.toString());
geom.setMaterial(debugAppState.DEBUG_PINK);
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
@Override
public void setSpatial(Spatial spatial) {
if (spatial != null && spatial instanceof Node) {
@@ -73,19 +109,43 @@ public class BulletCharacterDebugControl extends AbstractPhysicsDebugControl {
super.setSpatial(spatial);
}
+ /**
+ * Update this control. Invoked once per frame during the logical-state
+ * update, provided the control is enabled and added to a scene. Should be
+ * invoked only by a subclass or by AbstractControl.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
@Override
protected void controlUpdate(float tpf) {
- if(myShape != body.getCollisionShape()){
- Node node = (Node) this.spatial;
+ CollisionShape newShape = body.getCollisionShape();
+ Vector3f newScale = newShape.getScale();
+ if (myShape != newShape || !oldScale.equals(newScale)) {
+ myShape = newShape;
+ oldScale.set(newScale);
+
+ Node node = (Node) spatial;
node.detachChild(geom);
- geom = DebugShapeFactory.getDebugShape(body.getCollisionShape());
- geom.setMaterial(debugAppState.DEBUG_PINK);
+
+ geom = DebugShapeFactory.getDebugShape(myShape);
+ geom.setName(body.toString());
+
node.attachChild(geom);
}
- applyPhysicsTransform(body.getPhysicsLocation(location), Quaternion.IDENTITY);
- geom.setLocalScale(body.getCollisionShape().getScale());
+ geom.setMaterial(debugAppState.DEBUG_PINK);
+
+ body.getPhysicsLocation(location);
+ applyPhysicsTransform(location, Quaternion.IDENTITY);
}
+ /**
+ * Render this control. Invoked once per frame, provided the
+ * control is enabled and added to a scene. Should be invoked only by a
+ * subclass or by AbstractControl.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletDebugAppState.java b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletDebugAppState.java
index 4019d2c2b..3e2f6aef1 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletDebugAppState.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletDebugAppState.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -55,31 +55,84 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
+ * An app state to manage a debug visualization of a physics space.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class BulletDebugAppState extends AbstractAppState {
+ /**
+ * message logger for this class
+ */
protected static final Logger logger = Logger.getLogger(BulletDebugAppState.class.getName());
+ /**
+ * limit which objects are visualized, or null to visualize all objects
+ */
protected DebugAppStateFilter filter;
protected Application app;
protected AssetManager assetManager;
+ /**
+ * physics space to visualize (not null)
+ */
protected final PhysicsSpace space;
+ /**
+ * scene-graph node to parent the geometries
+ */
protected final Node physicsDebugRootNode = new Node("Physics Debug Root Node");
+ /**
+ * view port in which to render (not null)
+ */
protected ViewPort viewPort;
protected RenderManager rm;
+ /**
+ * material for inactive rigid bodies
+ */
public Material DEBUG_BLUE;
public Material DEBUG_RED;
+ /**
+ * material for joints
+ */
public Material DEBUG_GREEN;
+ /**
+ * material for ghosts
+ */
public Material DEBUG_YELLOW;
+ /**
+ * material for vehicles and active rigid bodies
+ */
public Material DEBUG_MAGENTA;
+ /**
+ * material for physics characters
+ */
public Material DEBUG_PINK;
+ /**
+ * map rigid bodies to visualizations
+ */
protected HashMap
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class BulletGhostObjectDebugControl extends AbstractPhysicsDebugControl {
+ /**
+ * ghost object to visualize (not null)
+ */
protected final PhysicsGhostObject body;
+ /**
+ * temporary storage for physics location
+ */
protected final Vector3f location = new Vector3f();
+ /**
+ * temporary storage for physics rotation
+ */
protected final Quaternion rotation = new Quaternion();
+ /**
+ * shape for which geom was generated (not null)
+ */
protected CollisionShape myShape;
+ /**
+ * geometry to visualize myShape (not null)
+ */
protected Spatial geom;
-
+ /**
+ * physics scale for which geom was generated
+ */
+ final private Vector3f oldScale = new Vector3f();
+ /**
+ * Instantiate an enabled control to visualize the specified ghost object.
+ *
+ * @param debugAppState which app state (not null, alias created)
+ * @param body which object to visualize (not null, alias created)
+ */
public BulletGhostObjectDebugControl(BulletDebugAppState debugAppState, PhysicsGhostObject body) {
super(debugAppState);
this.body = body;
myShape = body.getCollisionShape();
- this.geom = DebugShapeFactory.getDebugShape(body.getCollisionShape());
- this.geom.setName(body.toString());
+ oldScale.set(myShape.getScale());
+
+ this.geom = DebugShapeFactory.getDebugShape(myShape);
this.geom.setName(body.toString());
geom.setMaterial(debugAppState.DEBUG_YELLOW);
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
@Override
public void setSpatial(Spatial spatial) {
if (spatial != null && spatial instanceof Node) {
@@ -75,19 +110,44 @@ public class BulletGhostObjectDebugControl extends AbstractPhysicsDebugControl {
super.setSpatial(spatial);
}
+ /**
+ * Update this control. Invoked once per frame during the logical-state
+ * update, provided the control is enabled and added to a scene. Should be
+ * invoked only by a subclass or by AbstractControl.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
@Override
protected void controlUpdate(float tpf) {
- if (myShape != body.getCollisionShape()) {
- Node node = (Node) this.spatial;
+ CollisionShape newShape = body.getCollisionShape();
+ Vector3f newScale = newShape.getScale();
+ if (myShape != newShape || !oldScale.equals(newScale)) {
+ myShape = newShape;
+ oldScale.set(newScale);
+
+ Node node = (Node) spatial;
node.detachChild(geom);
- geom = DebugShapeFactory.getDebugShape(body.getCollisionShape());
- geom.setMaterial(debugAppState.DEBUG_YELLOW);
+
+ geom = DebugShapeFactory.getDebugShape(myShape);
+ geom.setName(body.toString());
+
node.attachChild(geom);
}
- applyPhysicsTransform(body.getPhysicsLocation(location), body.getPhysicsRotation(rotation));
- geom.setLocalScale(body.getCollisionShape().getScale());
+ geom.setMaterial(debugAppState.DEBUG_YELLOW);
+
+ body.getPhysicsLocation(location);
+ body.getPhysicsRotation(rotation);
+ applyPhysicsTransform(location, rotation);
}
+ /**
+ * Render this control. Invoked once per frame, provided the
+ * control is enabled and added to a scene. Should be invoked only by a
+ * subclass or by AbstractControl.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletJointDebugControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletJointDebugControl.java
index 571452811..7b11a41d6 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletJointDebugControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletJointDebugControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -43,6 +43,9 @@ import com.jme3.scene.Spatial;
import com.jme3.scene.debug.Arrow;
/**
+ * A physics-debug control used to visualize a PhysicsJoint.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
@@ -58,6 +61,12 @@ public class BulletJointDebugControl extends AbstractPhysicsDebugControl {
protected final Vector3f offA = new Vector3f();
protected final Vector3f offB = new Vector3f();
+ /**
+ * Instantiate an enabled control to visualize the specified joint.
+ *
+ * @param debugAppState which app state (not null, alias created)
+ * @param body the joint to visualize (not null, alias created)
+ */
public BulletJointDebugControl(BulletDebugAppState debugAppState, PhysicsJoint body) {
super(debugAppState);
this.body = body;
@@ -71,6 +80,13 @@ public class BulletJointDebugControl extends AbstractPhysicsDebugControl {
geomB.setMaterial(debugAppState.DEBUG_GREEN);
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
@Override
public void setSpatial(Spatial spatial) {
if (spatial != null && spatial instanceof Node) {
@@ -85,6 +101,13 @@ public class BulletJointDebugControl extends AbstractPhysicsDebugControl {
super.setSpatial(spatial);
}
+ /**
+ * Update this control. Invoked once per frame during the logical-state
+ * update, provided the control is enabled and added to a scene. Should be
+ * invoked only by a subclass or by AbstractControl.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
@Override
protected void controlUpdate(float tpf) {
body.getBodyA().getPhysicsLocation(a.getTranslation());
@@ -100,6 +123,14 @@ public class BulletJointDebugControl extends AbstractPhysicsDebugControl {
arrowB.setArrowExtent(body.getPivotB());
}
+ /**
+ * Render this control. Invoked once per frame, provided the
+ * control is enabled and added to a scene. Should be invoked only by a
+ * subclass or by AbstractControl.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletRigidBodyDebugControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletRigidBodyDebugControl.java
index 3bc10f3e6..727deebc3 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletRigidBodyDebugControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletRigidBodyDebugControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -42,26 +42,63 @@ import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
/**
+ * A physics-debug control used to visualize a PhysicsRigidBody.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class BulletRigidBodyDebugControl extends AbstractPhysicsDebugControl {
+ /**
+ * rigid body to visualize (not null)
+ */
protected final PhysicsRigidBody body;
+ /**
+ * temporary storage for physics location
+ */
protected final Vector3f location = new Vector3f();
+ /**
+ * temporary storage for physics rotation
+ */
protected final Quaternion rotation = new Quaternion();
+ /**
+ * shape for which geom was generated (not null)
+ */
protected CollisionShape myShape;
+ /**
+ * geometry to visualize myShape (not null)
+ */
protected Spatial geom;
+ /**
+ * physics scale for which geom was generated
+ */
+ final private Vector3f oldScale = new Vector3f();
+ /**
+ * Instantiate an enabled control to visualize the specified body.
+ *
+ * @param debugAppState which app state (not null, alias created)
+ * @param body which body to visualize (not null, alias created)
+ */
public BulletRigidBodyDebugControl(BulletDebugAppState debugAppState, PhysicsRigidBody body) {
super(debugAppState);
this.body = body;
myShape = body.getCollisionShape();
- this.geom = DebugShapeFactory.getDebugShape(body.getCollisionShape());
+ oldScale.set(myShape.getScale());
+
+ this.geom = DebugShapeFactory.getDebugShape(myShape);
this.geom.setName(body.toString());
geom.setMaterial(debugAppState.DEBUG_BLUE);
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
@Override
public void setSpatial(Spatial spatial) {
if (spatial != null && spatial instanceof Node) {
@@ -74,12 +111,27 @@ public class BulletRigidBodyDebugControl extends AbstractPhysicsDebugControl {
super.setSpatial(spatial);
}
+ /**
+ * Update this control. Invoked once per frame during the logical-state
+ * update, provided the control is enabled and added to a scene. Should be
+ * invoked only by a subclass or by AbstractControl.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
@Override
protected void controlUpdate(float tpf) {
- if(myShape != body.getCollisionShape()){
- Node node = (Node) this.spatial;
+ CollisionShape newShape = body.getCollisionShape();
+ Vector3f newScale = newShape.getScale();
+ if (myShape != newShape || !oldScale.equals(newScale)) {
+ myShape = newShape;
+ oldScale.set(newScale);
+
+ Node node = (Node) spatial;
node.detachChild(geom);
- geom = DebugShapeFactory.getDebugShape(body.getCollisionShape());
+
+ geom = DebugShapeFactory.getDebugShape(myShape);
+ geom.setName(body.toString());
+
node.attachChild(geom);
}
if(body.isActive()){
@@ -87,10 +139,20 @@ public class BulletRigidBodyDebugControl extends AbstractPhysicsDebugControl {
}else{
geom.setMaterial(debugAppState.DEBUG_BLUE);
}
- applyPhysicsTransform(body.getPhysicsLocation(location), body.getPhysicsRotation(rotation));
- geom.setLocalScale(body.getCollisionShape().getScale());
+
+ body.getPhysicsLocation(location);
+ body.getPhysicsRotation(rotation);
+ applyPhysicsTransform(location, rotation);
}
+ /**
+ * Render this control. Invoked once per frame, provided the
+ * control is enabled and added to a scene. Should be invoked only by a
+ * subclass or by AbstractControl.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletVehicleDebugControl.java b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletVehicleDebugControl.java
index f7adf1208..c964c420b 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletVehicleDebugControl.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/debug/BulletVehicleDebugControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -43,6 +43,9 @@ import com.jme3.scene.Spatial;
import com.jme3.scene.debug.Arrow;
/**
+ * A physics-debug control used to visualize a PhysicsVehicle.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
@@ -53,6 +56,12 @@ public class BulletVehicleDebugControl extends AbstractPhysicsDebugControl {
protected final Vector3f location = new Vector3f();
protected final Quaternion rotation = new Quaternion();
+ /**
+ * Instantiate an enabled control to visualize the specified vehicle.
+ *
+ * @param debugAppState which app state (not null, alias created)
+ * @param body which vehicle to visualize (not null, alias created)
+ */
public BulletVehicleDebugControl(BulletDebugAppState debugAppState, PhysicsVehicle body) {
super(debugAppState);
this.body = body;
@@ -60,6 +69,13 @@ public class BulletVehicleDebugControl extends AbstractPhysicsDebugControl {
createVehicle();
}
+ /**
+ * Alter which spatial is controlled. Invoked when the control is added to
+ * or removed from a spatial. Should be invoked only by a subclass or from
+ * Spatial. Do not invoke directly from user code.
+ *
+ * @param spatial the spatial to control (or null)
+ */
@Override
public void setSpatial(Spatial spatial) {
if (spatial != null && spatial instanceof Node) {
@@ -104,6 +120,13 @@ public class BulletVehicleDebugControl extends AbstractPhysicsDebugControl {
}
}
+ /**
+ * Update this control. Invoked once per frame during the logical-state
+ * update, provided the control is enabled and added to a scene. Should be
+ * invoked only by a subclass or by AbstractControl.
+ *
+ * @param tpf the time interval between frames (in seconds, ≥0)
+ */
@Override
protected void controlUpdate(float tpf) {
for (int i = 0; i < body.getNumWheels(); i++) {
@@ -136,6 +159,14 @@ public class BulletVehicleDebugControl extends AbstractPhysicsDebugControl {
applyPhysicsTransform(body.getPhysicsLocation(location), body.getPhysicsRotation(rotation));
}
+ /**
+ * Render this control. Invoked once per frame, provided the
+ * control is enabled and added to a scene. Should be invoked only by a
+ * subclass or by AbstractControl.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port to render (not null)
+ */
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
}
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/debug/DebugTools.java b/jme3-bullet/src/common/java/com/jme3/bullet/debug/DebugTools.java
index 2e7246b7a..16bc38ac8 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/debug/DebugTools.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/debug/DebugTools.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -42,43 +42,129 @@ import com.jme3.scene.Node;
import com.jme3.scene.debug.Arrow;
/**
+ * Debugging aids.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen
*/
public class DebugTools {
protected final AssetManager manager;
+ /**
+ * unshaded blue material
+ */
public Material DEBUG_BLUE;
+ /**
+ * unshaded red material
+ */
public Material DEBUG_RED;
+ /**
+ * unshaded green material
+ */
public Material DEBUG_GREEN;
+ /**
+ * unshaded yellow material
+ */
public Material DEBUG_YELLOW;
+ /**
+ * unshaded magenta material
+ */
public Material DEBUG_MAGENTA;
+ /**
+ * unshaded pink material
+ */
public Material DEBUG_PINK;
+ /**
+ * node for attaching debug geometries
+ */
public Node debugNode = new Node("Debug Node");
+ /**
+ * mesh for the blue arrow
+ */
public Arrow arrowBlue = new Arrow(Vector3f.ZERO);
+ /**
+ * geometry for the blue arrow
+ */
public Geometry arrowBlueGeom = new Geometry("Blue Arrow", arrowBlue);
+ /**
+ * mesh for the green arrow
+ */
public Arrow arrowGreen = new Arrow(Vector3f.ZERO);
+ /**
+ * geometry for the green arrow
+ */
public Geometry arrowGreenGeom = new Geometry("Green Arrow", arrowGreen);
+ /**
+ * mesh for the red arrow
+ */
public Arrow arrowRed = new Arrow(Vector3f.ZERO);
+ /**
+ * geometry for the red arrow
+ */
public Geometry arrowRedGeom = new Geometry("Red Arrow", arrowRed);
+ /**
+ * mesh for the magenta arrow
+ */
public Arrow arrowMagenta = new Arrow(Vector3f.ZERO);
+ /**
+ * geometry for the magenta arrow
+ */
public Geometry arrowMagentaGeom = new Geometry("Magenta Arrow", arrowMagenta);
+ /**
+ * mesh for the yellow arrow
+ */
public Arrow arrowYellow = new Arrow(Vector3f.ZERO);
+ /**
+ * geometry for the yellow arrow
+ */
public Geometry arrowYellowGeom = new Geometry("Yellow Arrow", arrowYellow);
+ /**
+ * mesh for the pink arrow
+ */
public Arrow arrowPink = new Arrow(Vector3f.ZERO);
+ /**
+ * geometry for the pink arrow
+ */
public Geometry arrowPinkGeom = new Geometry("Pink Arrow", arrowPink);
+ /**
+ * local copy of {@link com.jme3.math.Vector3f#UNIT_X}
+ */
protected static final Vector3f UNIT_X_CHECK = new Vector3f(1, 0, 0);
+ /**
+ * local copy of {@link com.jme3.math.Vector3f#UNIT_Y}
+ */
protected static final Vector3f UNIT_Y_CHECK = new Vector3f(0, 1, 0);
+ /**
+ * local copy of {@link com.jme3.math.Vector3f#UNIT_Z}
+ */
protected static final Vector3f UNIT_Z_CHECK = new Vector3f(0, 0, 1);
+ /**
+ * local copy of {@link com.jme3.math.Vector3f#UNIT_XYZ}
+ */
protected static final Vector3f UNIT_XYZ_CHECK = new Vector3f(1, 1, 1);
+ /**
+ * local copy of {@link com.jme3.math.Vector3f#ZERO}
+ */
protected static final Vector3f ZERO_CHECK = new Vector3f(0, 0, 0);
+ /**
+ * Instantiate a set of debug tools.
+ *
+ * @param manager for loading assets (not null, alias created)
+ */
public DebugTools(AssetManager manager) {
this.manager = manager;
setupMaterials();
setupDebugNode();
}
+ /**
+ * Render all the debug geometries to the specified view port.
+ *
+ * @param rm the render manager (not null)
+ * @param vp the view port (not null)
+ */
public void show(RenderManager rm, ViewPort vp) {
if (!Vector3f.UNIT_X.equals(UNIT_X_CHECK) || !Vector3f.UNIT_Y.equals(UNIT_Y_CHECK) || !Vector3f.UNIT_Z.equals(UNIT_Z_CHECK)
|| !Vector3f.UNIT_XYZ.equals(UNIT_XYZ_CHECK) || !Vector3f.ZERO.equals(ZERO_CHECK)) {
@@ -94,36 +180,75 @@ public class DebugTools {
rm.renderScene(debugNode, vp);
}
+ /**
+ * Alter the location and extent of the blue arrow.
+ *
+ * @param location the coordinates of the tail (not null, unaffected)
+ * @param extent the offset of the tip from the tail (not null, unaffected)
+ */
public void setBlueArrow(Vector3f location, Vector3f extent) {
arrowBlueGeom.setLocalTranslation(location);
arrowBlue.setArrowExtent(extent);
}
+ /**
+ * Alter the location and extent of the green arrow.
+ *
+ * @param location the coordinates of the tail (not null, unaffected)
+ * @param extent the offset of the tip from the tail (not null, unaffected)
+ */
public void setGreenArrow(Vector3f location, Vector3f extent) {
arrowGreenGeom.setLocalTranslation(location);
arrowGreen.setArrowExtent(extent);
}
+ /**
+ * Alter the location and extent of the red arrow.
+ *
+ * @param location the coordinates of the tail (not null, unaffected)
+ * @param extent the offset of the tip from the tail (not null, unaffected)
+ */
public void setRedArrow(Vector3f location, Vector3f extent) {
arrowRedGeom.setLocalTranslation(location);
arrowRed.setArrowExtent(extent);
}
+ /**
+ * Alter the location and extent of the magenta arrow.
+ *
+ * @param location the coordinates of the tail (not null, unaffected)
+ * @param extent the offset of the tip from the tail (not null, unaffected)
+ */
public void setMagentaArrow(Vector3f location, Vector3f extent) {
arrowMagentaGeom.setLocalTranslation(location);
arrowMagenta.setArrowExtent(extent);
}
+ /**
+ * Alter the location and extent of the yellow arrow.
+ *
+ * @param location the coordinates of the tail (not null, unaffected)
+ * @param extent the offset of the tip from the tail (not null, unaffected)
+ */
public void setYellowArrow(Vector3f location, Vector3f extent) {
arrowYellowGeom.setLocalTranslation(location);
arrowYellow.setArrowExtent(extent);
}
+ /**
+ * Alter the location and extent of the pink arrow.
+ *
+ * @param location the coordinates of the tail (not null, unaffected)
+ * @param extent the offset of the tip from the tail (not null, unaffected)
+ */
public void setPinkArrow(Vector3f location, Vector3f extent) {
arrowPinkGeom.setLocalTranslation(location);
arrowPink.setArrowExtent(extent);
}
+ /**
+ * Attach all the debug geometries to the debug node.
+ */
protected void setupDebugNode() {
arrowBlueGeom.setMaterial(DEBUG_BLUE);
arrowGreenGeom.setMaterial(DEBUG_GREEN);
@@ -139,6 +264,9 @@ public class DebugTools {
debugNode.attachChild(arrowPinkGeom);
}
+ /**
+ * Initialize all the DebugTools materials.
+ */
protected void setupMaterials() {
DEBUG_BLUE = new Material(manager, "Common/MatDefs/Misc/Unshaded.j3md");
DEBUG_BLUE.getAdditionalRenderState().setWireframe(true);
diff --git a/jme3-bullet/src/common/java/com/jme3/bullet/util/CollisionShapeFactory.java b/jme3-bullet/src/common/java/com/jme3/bullet/util/CollisionShapeFactory.java
index de28aba02..19e14d49b 100644
--- a/jme3-bullet/src/common/java/com/jme3/bullet/util/CollisionShapeFactory.java
+++ b/jme3-bullet/src/common/java/com/jme3/bullet/util/CollisionShapeFactory.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -44,17 +44,21 @@ import java.util.Iterator;
import java.util.LinkedList;
/**
+ * A utility class for generating collision shapes from Spatials.
+ *
+ * This class is shared between JBullet and Native Bullet.
*
* @author normenhansen, tim8dev
*/
public class CollisionShapeFactory {
/**
- * returns the correct transform for a collisionshape in relation
- * to the ancestor for which the collisionshape is generated
+ * Calculate the correct transform for a collision shape relative to the
+ * ancestor for which the shape was generated.
+ *
* @param spat
* @param parent
- * @return
+ * @return a new instance (not null)
*/
private static Transform getTransform(Spatial spat, Spatial parent) {
Transform shapeTransform = new Transform();
@@ -135,30 +139,48 @@ public class CollisionShapeFactory {
}
/**
- * This type of collision shape is mesh-accurate and meant for immovable "world objects".
- * Examples include terrain, houses or whole shooter levels.
+ * Objects with "mesh" type collision shape will not collide with each
+ * other.
+ *
+ * @param rootNode the node on which to base the shape (not null)
+ * @return a new shape (not null)
*/
private static CompoundCollisionShape createMeshCompoundShape(Node rootNode) {
return createCompoundShape(rootNode, new CompoundCollisionShape(), true);
}
/**
- * This type of collision shape creates a CompoundShape made out of boxes that
- * are based on the bounds of the Geometries in the tree.
- * @param rootNode
- * @return
+ * This type of collision shape creates a CompoundShape made out of boxes
+ * that are based on the bounds of the Geometries in the tree.
+ *
+ * @param rootNode the node on which to base the shape (not null)
+ * @return a new shape (not null)
*/
private static CompoundCollisionShape createBoxCompoundShape(Node rootNode) {
return createCompoundShape(rootNode, new CompoundCollisionShape(), false);
}
/**
- * This type of collision shape is mesh-accurate and meant for immovable "world objects".
- * Examples include terrain, houses or whole shooter levels.
+ * This type of collision shape is mesh-accurate and meant for immovable
+ * "world objects". Examples include terrain, houses or whole shooter
+ * levels.
+ *
+ * Objects with "mesh" type collision shape will not collide with each
+ * other.
+ *
+ * Creates a HeightfieldCollisionShape if the supplied spatial is a
+ * TerrainQuad.
+ *
+ * @param spatial the spatial on which to base the shape (not null)
+ * @return A MeshCollisionShape or a CompoundCollisionShape with
+ * MeshCollisionShapes as children if the supplied spatial is a Node. A
+ * HeightieldCollisionShape if a TerrainQuad was supplied.
*/
public static CollisionShape createMeshShape(Spatial spatial) {
if (spatial instanceof TerrainQuad) {
@@ -177,9 +199,14 @@ public class CollisionShapeFactory {
}
/**
- * This method creates a hull shape for the given Spatial.
+ * For mesh-accurate animated meshes (CPU intense!) use GImpact shapes.
+ *
+ * @param spatial the spatial on which to base the shape (not null)
+ * @return a HullCollisionShape (if spatial is a Geometry) or a
+ * CompoundCollisionShape with HullCollisionShapes as children (if spatial
+ * is a Node)
*/
public static CollisionShape createDynamicMeshShape(Spatial spatial) {
if (spatial instanceof Geometry) {
@@ -192,6 +219,14 @@ public class CollisionShapeFactory {
}
+ /**
+ * Create a box shape for the given Spatial.
+ *
+ * @param spatial the spatial on which to base the shape (not null)
+ * @return a BoxCollisionShape (if spatial is a Geometry) or a
+ * CompoundCollisionShape with BoxCollisionShapes as children (if spatial is
+ * a Node)
+ */
public static CollisionShape createBoxShape(Spatial spatial) {
if (spatial instanceof Geometry) {
return createSingleBoxShape((Geometry) spatial, spatial);
@@ -203,9 +238,12 @@ public class CollisionShapeFactory {
}
/**
- * This type of collision shape is mesh-accurate and meant for immovable "world objects".
- * Examples include terrain, houses or whole shooter levels.
+ * Objects with "mesh" type collision shape will not collide with each
+ * other.
*/
private static MeshCollisionShape createSingleMeshShape(Geometry geom, Spatial parent) {
Mesh mesh = geom.getMesh();
@@ -220,9 +258,13 @@ public class CollisionShapeFactory {
}
/**
- * Uses the bounding box of the supplied spatial to create a BoxCollisionShape
- * @param spatial
- * @return BoxCollisionShape with the size of the spatials BoundingBox
+ * Use the bounding box of the supplied spatial to create a
+ * BoxCollisionShape.
+ *
+ * @param spatial the spatial on which to base the shape (not null)
+ * @param parent unused
+ * @return a new shape with the dimensions of the spatial's bounding box
+ * (not null)
*/
private static BoxCollisionShape createSingleBoxShape(Spatial spatial, Spatial parent) {
//TODO: using world bound here instead of "local world" bound...
@@ -232,7 +274,10 @@ public class CollisionShapeFactory {
}
/**
- * This method creates a hull collision shape for the given mesh. PhysicsSpace - The central jbullet-jme physics space
+ * This method is invoked from native code.
+ *
+ * @param timeStep the time per physics step (in seconds, ≥0)
+ */
private void preTick_native(float f) {
- AppTask task = pQueue.poll();
- task = pQueue.poll();
- while (task != null) {
- while (task.isCancelled()) {
- task = pQueue.poll();
- }
- try {
+ AppTask task;
+ while((task=pQueue.poll())!=null){
+ if(task.isCancelled())continue;
+ try{
task.invoke();
} catch (Exception ex) {
logger.log(Level.SEVERE, null, ex);
}
- task = pQueue.poll();
}
+
for (Iterator
+ * This method is invoked from native code.
+ *
+ * @param timeStep the time per physics step (in seconds, ≥0)
+ */
private void postTick_native(float f) {
for (Iterator
+ * Whenever a rigid body is added to a space, the body's gravity gets set to
+ * that of the space. Thus it makes sense to set the space's vector before
+ * adding any bodies to the space.
*
- * @param gravity
+ * @param gravity the desired acceleration vector (not null, unaffected)
*/
public void setGravity(Vector3f gravity) {
this.gravity.set(gravity);
@@ -712,8 +888,17 @@ public class PhysicsSpace {
private native void setGravity(long spaceId, Vector3f gravity);
- //TODO: getGravity
+ /**
+ * copy of gravity-acceleration vector (default is 9.81 in the -Y direction,
+ * corresponding to Earth-normal in MKS units)
+ */
private final Vector3f gravity = new Vector3f(0,-9.81f,0);
+ /**
+ * Copy the gravitational acceleration acting on newly-added bodies.
+ *
+ * @param gravity storage for the result (not null, modified)
+ * @return acceleration (in the vector provided)
+ */
public Vector3f getGravity(Vector3f gravity) {
return gravity.set(this.gravity);
}
@@ -733,57 +918,89 @@ public class PhysicsSpace {
// }
//
/**
- * Adds the specified listener to the physics tick listeners. The listeners
- * are called on each physics step, which is not necessarily each frame but
- * is determined by the accuracy of the physics space.
+ * Register the specified tick listener with this space.
+ *
+ * Tick listeners are notified before and after each physics step. A physics
+ * step is not necessarily the same as a frame; it is more influenced by the
+ * accuracy of the physics space.
+ *
+ * @see #setAccuracy(float)
*
- * @param listener
+ * @param listener the listener to register (not null)
*/
public void addTickListener(PhysicsTickListener listener) {
tickListeners.add(listener);
}
+ /**
+ * De-register the specified tick listener.
+ *
+ * @see #addTickListener(com.jme3.bullet.PhysicsTickListener)
+ * @param listener the listener to de-register (not null)
+ */
public void removeTickListener(PhysicsTickListener listener) {
tickListeners.remove(listener);
}
/**
- * Adds a CollisionListener that will be informed about collision events
+ * Register the specified collision listener with this space.
+ *
+ * Collision listeners are notified when collisions occur in the space.
*
- * @param listener the CollisionListener to add
+ * @param listener the listener to register (not null, alias created)
*/
public void addCollisionListener(PhysicsCollisionListener listener) {
collisionListeners.add(listener);
}
/**
- * Removes a CollisionListener from the list
+ * De-register the specified collision listener.
*
- * @param listener the CollisionListener to remove
+ * @see
+ * #addCollisionListener(com.jme3.bullet.collision.PhysicsCollisionListener)
+ * @param listener the listener to de-register (not null)
*/
public void removeCollisionListener(PhysicsCollisionListener listener) {
collisionListeners.remove(listener);
}
/**
- * Adds a listener for a specific collision group, such a listener can
- * disable collisions when they happen.
+ * Such a listener can disable collisions when they occur. There can be only
+ * one listener per collision group per space.
*
- * @param listener
- * @param collisionGroup
+ * @param listener the listener to register (not null)
+ * @param collisionGroup which group it should listen for (bit mask with
+ * exactly one bit set)
*/
public void addCollisionGroupListener(PhysicsCollisionGroupListener listener, int collisionGroup) {
collisionGroupListeners.put(collisionGroup, listener);
}
+ /**
+ * De-register the specified collision-group listener.
+ *
+ * @see
+ * #addCollisionGroupListener(com.jme3.bullet.collision.PhysicsCollisionGroupListener,
+ * int)
+ * @param collisionGroup the group of the listener to de-register (bit mask
+ * with exactly one bit set)
+ */
public void removeCollisionGroupListener(int collisionGroup) {
collisionGroupListeners.remove(collisionGroup);
}
/**
- * Performs a ray collision test and returns the results as a list of
- * PhysicsRayTestResults ordered by it hitFraction (lower to higher)
+ * Perform a ray-collision test and return the results as a list of
+ * PhysicsRayTestResults sorted by ascending hitFraction.
+ *
+ * @param from the starting location (physics-space coordinates, not null,
+ * unaffected)
+ * @param to the ending location (in physics-space coordinates, not null,
+ * unaffected)
+ * @return a new list of results (not null)
*/
public List rayTest(Vector3f from, Vector3f to) {
List
+ * The starting and ending locations must be at least 0.4f physics-space
+ * units apart.
+ *
+ * A sweep test will miss a collision if it starts inside an object and
+ * sweeps away from the object's center.
+ *
+ * @param shape the shape to sweep (not null)
+ * @param start the starting physics-space transform (not null)
+ * @param end the ending physics-space transform (not null)
+ * @return a new list of results
*/
public List
+ * The starting and ending locations must be at least 0.4f physics-space
+ * units apart.
+ *
+ * A sweep test will miss a collision if it starts inside an object and
+ * sweeps away from the object's center.
+ *
+ * @param shape the shape to sweep (not null)
+ * @param start the starting physics-space transform (not null)
+ * @param end the ending physics-space transform (not null)
+ * @param results the list to hold results (not null, modified)
+ * @return results
+ */
public List
+ * The starting and ending locations must be at least 0.4f physics-space
+ * units apart.
+ *
+ * A sweep test will miss a collision if it starts inside an object and
+ * sweeps away from the object's center.
+ *
+ * @param shape the shape to sweep (not null)
+ * @param start the starting physics-space transform (not null)
+ * @param end the ending physics-space transform (not null)
+ * @param results the list to hold results (not null, modified)
+ * @param allowedCcdPenetration true→allow, false→disallow
+ * @return results
*/
public List
+ * Extra physics steps help maintain determinism when the render fps drops
+ * below 1/accuracy. For example a value of 2 can compensate for frame rates
+ * as low as 30fps, assuming the physics has an accuracy of 1/60 sec.
+ *
+ * Setting this value too high can depress the frame rate.
*
- * @param steps The maximum number of extra steps, default is 4.
+ * @param steps the desired maximum number of steps per frame (≥1,
+ * default=4)
*/
public void setMaxSubSteps(int steps) {
maxSubSteps = steps;
}
/**
- * get the current accuracy of the physics computation
+ * Read the accuracy (time step) of the physics simulation.
*
- * @return the current accuracy
+ * @return the timestep (in seconds, >0)
*/
public float getAccuracy() {
return accuracy;
}
/**
- * sets the accuracy of the physics computation, default=1/60s
+ * In general, the smaller the time step, the more accurate (and
+ * compute-intensive) the simulation will be. Bullet works best with a
+ * time step of no more than 1/60 second.
*
- * @param accuracy
+ * @param accuracy the desired time step (in seconds, >0, default=1/60)
*/
public void setAccuracy(float accuracy) {
this.accuracy = accuracy;
}
+ /**
+ * Access the minimum coordinate values for this space.
+ *
+ * @return the pre-existing vector
+ */
public Vector3f getWorldMin() {
return worldMin;
}
/**
- * only applies for AXIS_SWEEP broadphase
+ * Alter the minimum coordinate values for this space. (only affects
+ * AXIS_SWEEP broadphase algorithms)
*
- * @param worldMin
+ * @param worldMin the desired minimum coordinate values (not null,
+ * unaffected)
*/
public void setWorldMin(Vector3f worldMin) {
this.worldMin.set(worldMin);
}
+ /**
+ * Access the maximum coordinate values for this space.
+ *
+ * @return the pre-existing vector (not null)
+ */
public Vector3f getWorldMax() {
return worldMax;
}
@@ -1007,11 +1308,11 @@ public class PhysicsSpace {
}
/**
- * Set the number of iterations used by the contact solver.
- *
- * The default is 10. Use 4 for low quality, 20 for high quality.
- *
- * @param numIterations The number of iterations used by the contact & constraint solver.
+ * Alter the number of iterations used by the contact-and-constraint solver.
+ *
+ * Use 4 for low quality, 20 for high quality.
+ *
+ * @param numIterations the desired number of iterations (≥1, default=10)
*/
public void setSolverNumIterations(int numIterations) {
this.solverNumIterations = numIterations;
@@ -1019,9 +1320,9 @@ public class PhysicsSpace {
}
/**
- * Get the number of iterations used by the contact solver.
- *
- * @return The number of iterations used by the contact & constraint solver.
+ * Read the number of iterations used by the contact-and-constraint solver.
+ *
+ * @return the number of iterations used
*/
public int getSolverNumIterations() {
return solverNumIterations;
@@ -1032,28 +1333,40 @@ public class PhysicsSpace {
public static native void initNativePhysics();
/**
- * interface with Broadphase types
+ * Enumerate the available acceleration structures for broadphase collision
+ * detection.
*/
public enum BroadphaseType {
/**
- * basic Broadphase
+ * btSimpleBroadphase: a brute-force reference implementation for
+ * debugging purposes
*/
SIMPLE,
/**
- * better Broadphase, needs worldBounds , max Object number = 16384
+ * btAxisSweep3: uses incremental 3-D sweep and prune, requires world
+ * bounds, limited to 16_384 objects
*/
AXIS_SWEEP_3,
/**
- * better Broadphase, needs worldBounds , max Object number = 65536
+ * bt32BitAxisSweep3: uses incremental 3-D sweep and prune, requires
+ * world bounds, limited to 65_536 objects
*/
AXIS_SWEEP_3_32,
/**
- * Broadphase allowing quicker adding/removing of physics objects
+ * btDbvtBroadphase: uses a fast, dynamic bounding-volume hierarchy
+ * based on AABB tree to allow quicker addition/removal of physics
+ * objects
*/
DBVT;
}
+ /**
+ * Finalize this physics space just before it is destroyed. Should be
+ * invoked only by a subclass or by the garbage collector.
+ *
+ * @throws Throwable ignored by the garbage collector
+ */
@Override
protected void finalize() throws Throwable {
super.finalize();
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/CollisionFlag.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/CollisionFlag.java
new file mode 100644
index 000000000..6445af53f
--- /dev/null
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/CollisionFlag.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2018 jMonkeyEngine
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.jme3.bullet.collision;
+
+/**
+ * Named collision flags for a {@link PhysicsCollisionObject}. Values must agree
+ * with those in BulletCollision/CollisionDispatch/btCollisionObject.h
+ *
+ * @author Stephen Gold sgold@sonic.net
+ * @see PhysicsCollisionObject#getCollisionFlags(long)
+ */
+public class CollisionFlag {
+ /**
+ * flag for a static object
+ */
+ final public static int STATIC_OBJECT = 0x1;
+ /**
+ * flag for a kinematic object
+ */
+ final public static int KINEMATIC_OBJECT = 0x2;
+ /**
+ * flag for an object with no contact response, such as a PhysicsGhostObject
+ */
+ final public static int NO_CONTACT_RESPONSE = 0x4;
+ /**
+ * flag to enable a custom material callback for per-triangle
+ * friction/restitution (not used by JME)
+ */
+ final public static int CUSTOM_MATERIAL_CALLBACK = 0x8;
+ /**
+ * flag for a character object, such as a PhysicsCharacter
+ */
+ final public static int CHARACTER_OBJECT = 0x10;
+ /**
+ * flag to disable debug visualization (not used by JME)
+ */
+ final public static int DISABLE_VISUALIZE_OBJECT = 0x20;
+ /**
+ * flag to disable parallel/SPU processing (not used by JME)
+ */
+ final public static int DISABLE_SPU_COLLISION_PROCESSING = 0x40;
+ /**
+ * flag not used by JME
+ */
+ final public static int HAS_CONTACT_STIFFNESS_DAMPING = 0x80;
+ /**
+ * flag not used by JME
+ */
+ final public static int HAS_CUSTOM_DEBUG_RENDERING_COLOR = 0x100;
+ /**
+ * flag not used by JME
+ */
+ final public static int HAS_FRICTION_ANCHOR = 0x200;
+ /**
+ * flag not used by JME
+ */
+ final public static int HAS_COLLISION_SOUND_TRIGGER = 0x400;
+}
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEvent.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEvent.java
index 0022ebd1c..bb6276002 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEvent.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEvent.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -36,21 +36,53 @@ import com.jme3.scene.Spatial;
import java.util.EventObject;
/**
- * A CollisionEvent stores all information about a collision in the PhysicsWorld.
- * Do not store this Object, as it will be reused after the collision() method has been called.
- * Get/reference all data you need in the collide method.
+ * Describe a collision in the physics world.
+ *
+ * Do not retain this object, as it will be reused after the collision() method
+ * returns. Copy any data you need during the collide() method.
+ *
* @author normenhansen
*/
public class PhysicsCollisionEvent extends EventObject {
+ /**
+ * type value to indicate a new event
+ */
public static final int TYPE_ADDED = 0;
+ /**
+ * type value to indicate an event that has been added to a PhysicsSpace
+ * queue
+ */
public static final int TYPE_PROCESSED = 1;
+ /**
+ * type value to indicate a cleaned/destroyed event
+ */
public static final int TYPE_DESTROYED = 2;
+ /**
+ * type value that indicates the event's status
+ */
private int type;
+ /**
+ * 1st involved object
+ */
private PhysicsCollisionObject nodeA;
+ /**
+ * 2nd involved object
+ */
private PhysicsCollisionObject nodeB;
+ /**
+ * Bullet identifier of the btManifoldPoint
+ */
private long manifoldPointObjectId = 0;
+ /**
+ * Instantiate a collision event.
+ *
+ * @param type event type (0=added/1=processed/2=destroyed)
+ * @param nodeA 1st involved object (alias created)
+ * @param nodeB 2nd involved object (alias created)
+ * @param manifoldPointObjectId Bullet identifier of the btManifoldPoint
+ */
public PhysicsCollisionEvent(int type, PhysicsCollisionObject nodeA, PhysicsCollisionObject nodeB, long manifoldPointObjectId) {
super(nodeA);
this.type = type;
@@ -58,9 +90,9 @@ public class PhysicsCollisionEvent extends EventObject {
this.nodeB = nodeB;
this.manifoldPointObjectId = manifoldPointObjectId;
}
-
+
/**
- * used by event factory, called when event is destroyed
+ * Destroy this event.
*/
public void clean() {
source = null;
@@ -71,7 +103,12 @@ public class PhysicsCollisionEvent extends EventObject {
}
/**
- * used by event factory, called when event reused
+ * Reuse this event.
+ *
+ * @param type event type (added/processed/destroyed)
+ * @param source 1st involved object (alias created)
+ * @param nodeB 2nd involved object (alias created)
+ * @param manifoldPointObjectId Bullet identifier
*/
public void refactor(int type, PhysicsCollisionObject source, PhysicsCollisionObject nodeB, long manifoldPointObjectId) {
this.source = source;
@@ -81,12 +118,19 @@ public class PhysicsCollisionEvent extends EventObject {
this.manifoldPointObjectId = manifoldPointObjectId;
}
+ /**
+ * Read the type of event.
+ *
+ * @return added/processed/destroyed
+ */
public int getType() {
return type;
}
/**
- * @return A Spatial if the UserObject of the PhysicsCollisionObject is a Spatial
+ * Access the user object of collision object A, provided it's a Spatial.
+ *
+ * @return the pre-existing Spatial, or null if none
*/
public Spatial getNodeA() {
if (nodeA.getUserObject() instanceof Spatial) {
@@ -96,7 +140,9 @@ public class PhysicsCollisionEvent extends EventObject {
}
/**
- * @return A Spatial if the UserObject of the PhysicsCollisionObject is a Spatial
+ * Access the user object of collision object B, provided it's a Spatial.
+ *
+ * @return the pre-existing Spatial, or null if none
*/
public Spatial getNodeB() {
if (nodeB.getUserObject() instanceof Spatial) {
@@ -105,139 +151,286 @@ public class PhysicsCollisionEvent extends EventObject {
return null;
}
+ /**
+ * Access collision object A.
+ *
+ * @return the pre-existing object (not null)
+ */
public PhysicsCollisionObject getObjectA() {
return nodeA;
}
+ /**
+ * Access collision object B.
+ *
+ * @return the pre-existing object (not null)
+ */
public PhysicsCollisionObject getObjectB() {
return nodeB;
}
+ /**
+ * Read the collision's applied impulse.
+ *
+ * @return impulse
+ */
public float getAppliedImpulse() {
return getAppliedImpulse(manifoldPointObjectId);
}
private native float getAppliedImpulse(long manifoldPointObjectId);
+ /**
+ * Read the collision's applied lateral impulse #1.
+ *
+ * @return impulse
+ */
public float getAppliedImpulseLateral1() {
return getAppliedImpulseLateral1(manifoldPointObjectId);
}
private native float getAppliedImpulseLateral1(long manifoldPointObjectId);
+ /**
+ * Read the collision's applied lateral impulse #2.
+ *
+ * @return impulse
+ */
public float getAppliedImpulseLateral2() {
return getAppliedImpulseLateral2(manifoldPointObjectId);
}
private native float getAppliedImpulseLateral2(long manifoldPointObjectId);
+ /**
+ * Read the collision's combined friction.
+ *
+ * @return friction
+ */
public float getCombinedFriction() {
return getCombinedFriction(manifoldPointObjectId);
}
private native float getCombinedFriction(long manifoldPointObjectId);
+ /**
+ * Read the collision's combined restitution.
+ *
+ * @return restitution
+ */
public float getCombinedRestitution() {
return getCombinedRestitution(manifoldPointObjectId);
}
private native float getCombinedRestitution(long manifoldPointObjectId);
+ /**
+ * Read the collision's distance #1.
+ *
+ * @return distance
+ */
public float getDistance1() {
return getDistance1(manifoldPointObjectId);
}
private native float getDistance1(long manifoldPointObjectId);
+ /**
+ * Read the collision's index 0.
+ *
+ * @return index
+ */
public int getIndex0() {
return getIndex0(manifoldPointObjectId);
}
private native int getIndex0(long manifoldPointObjectId);
+ /**
+ * Read the collision's index 1.
+ *
+ * @return index
+ */
public int getIndex1() {
return getIndex1(manifoldPointObjectId);
}
private native int getIndex1(long manifoldPointObjectId);
+ /**
+ * Copy the collision's lateral friction direction #1.
+ *
+ * @return a new vector (not null)
+ */
public Vector3f getLateralFrictionDir1() {
return getLateralFrictionDir1(new Vector3f());
}
+ /**
+ * Copy the collision's lateral friction direction #1.
+ *
+ * @param lateralFrictionDir1 storage for the result (not null, modified)
+ * @return direction vector (not null)
+ */
public Vector3f getLateralFrictionDir1(Vector3f lateralFrictionDir1) {
getLateralFrictionDir1(manifoldPointObjectId, lateralFrictionDir1);
return lateralFrictionDir1;
}
private native void getLateralFrictionDir1(long manifoldPointObjectId, Vector3f lateralFrictionDir1);
+ /**
+ * Copy the collision's lateral friction direction #2.
+ *
+ * @return a new vector
+ */
public Vector3f getLateralFrictionDir2() {
return getLateralFrictionDir2(new Vector3f());
}
+ /**
+ * Copy the collision's lateral friction direction #2.
+ *
+ * @param lateralFrictionDir2 storage for the result (not null, modified)
+ * @return direction vector (not null)
+ */
public Vector3f getLateralFrictionDir2(Vector3f lateralFrictionDir2) {
getLateralFrictionDir2(manifoldPointObjectId, lateralFrictionDir2);
return lateralFrictionDir2;
}
private native void getLateralFrictionDir2(long manifoldPointObjectId, Vector3f lateralFrictionDir2);
+ /**
+ * Test whether the collision's lateral friction is initialized.
+ *
+ * @return true if initialized, otherwise false
+ */
public boolean isLateralFrictionInitialized() {
return isLateralFrictionInitialized(manifoldPointObjectId);
}
private native boolean isLateralFrictionInitialized(long manifoldPointObjectId);
+ /**
+ * Read the collision's lifetime.
+ *
+ * @return lifetime
+ */
public int getLifeTime() {
return getLifeTime(manifoldPointObjectId);
}
private native int getLifeTime(long manifoldPointObjectId);
+ /**
+ * Copy the collision's location in the local coordinates of object A.
+ *
+ * @return a new location vector (in local coordinates, not null)
+ */
public Vector3f getLocalPointA() {
return getLocalPointA(new Vector3f());
}
+ /**
+ * Copy the collision's location in the local coordinates of object A.
+ *
+ * @param localPointA storage for the result (not null, modified)
+ * @return a location vector (in local coordinates, not null)
+ */
public Vector3f getLocalPointA(Vector3f localPointA) {
getLocalPointA(manifoldPointObjectId, localPointA);
return localPointA;
}
private native void getLocalPointA(long manifoldPointObjectId, Vector3f localPointA);
+ /**
+ * Copy the collision's location in the local coordinates of object B.
+ *
+ * @return a new location vector (in local coordinates, not null)
+ */
public Vector3f getLocalPointB() {
return getLocalPointB(new Vector3f());
}
+ /**
+ * Copy the collision's location in the local coordinates of object B.
+ *
+ * @param localPointB storage for the result (not null, modified)
+ * @return a location vector (in local coordinates, not null)
+ */
public Vector3f getLocalPointB(Vector3f localPointB) {
getLocalPointB(manifoldPointObjectId, localPointB);
return localPointB;
}
private native void getLocalPointB(long manifoldPointObjectId, Vector3f localPointB);
+ /**
+ * Copy the collision's normal on object B.
+ *
+ * @return a new normal vector (in physics-space coordinates, not null)
+ */
public Vector3f getNormalWorldOnB() {
return getNormalWorldOnB(new Vector3f());
}
+ /**
+ * Copy the collision's normal on object B.
+ *
+ * @param normalWorldOnB storage for the result (not null, modified)
+ * @return a normal vector (in physics-space coordinates, not null)
+ */
public Vector3f getNormalWorldOnB(Vector3f normalWorldOnB) {
getNormalWorldOnB(manifoldPointObjectId, normalWorldOnB);
return normalWorldOnB;
}
private native void getNormalWorldOnB(long manifoldPointObjectId, Vector3f normalWorldOnB);
+ /**
+ * Read part identifier 0.
+ *
+ * @return identifier
+ */
public int getPartId0() {
return getPartId0(manifoldPointObjectId);
}
private native int getPartId0(long manifoldPointObjectId);
+ /**
+ * Read part identifier 1.
+ *
+ * @return identifier
+ */
public int getPartId1() {
return getPartId1(manifoldPointObjectId);
}
private native int getPartId1(long manifoldPointObjectId);
+ /**
+ * Copy the collision's location.
+ *
+ * @return a new vector (in physics-space coordinates, not null)
+ */
public Vector3f getPositionWorldOnA() {
return getPositionWorldOnA(new Vector3f());
}
+ /**
+ * Copy the collision's location.
+ *
+ * @param positionWorldOnA storage for the result (not null, modified)
+ * @return a location vector (in physics-space coordinates, not null)
+ */
public Vector3f getPositionWorldOnA(Vector3f positionWorldOnA) {
getPositionWorldOnA(manifoldPointObjectId, positionWorldOnA);
return positionWorldOnA;
}
private native void getPositionWorldOnA(long manifoldPointObjectId, Vector3f positionWorldOnA);
+ /**
+ * Copy the collision's location.
+ *
+ * @return a new location vector (in physics-space coordinates, not null)
+ */
public Vector3f getPositionWorldOnB() {
return getPositionWorldOnB(new Vector3f());
}
+ /**
+ * Copy the collision's location.
+ *
+ * @param positionWorldOnB storage for the result (not null, modified)
+ * @return a location vector (in physics-space coordinates, not null)
+ */
public Vector3f getPositionWorldOnB(Vector3f positionWorldOnB) {
getPositionWorldOnB(manifoldPointObjectId, positionWorldOnB);
return positionWorldOnB;
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEventFactory.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEventFactory.java
index 8c328a15f..d8eb11879 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEventFactory.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsCollisionEventFactory.java
@@ -41,6 +41,11 @@ public class PhysicsCollisionEventFactory {
private ConcurrentLinkedQueue
+ * Collision objects include PhysicsCharacter, PhysicsRigidBody, and
+ * PhysicsGhostObject.
+ *
* @author normenhansen
*/
public abstract class PhysicsCollisionObject implements Savable {
+ /**
+ * Unique identifier of the btCollisionObject. Constructors are responsible
+ * for setting this to a non-zero value. The id might change if the object
+ * gets rebuilt.
+ */
protected long objectId = 0;
+ /**
+ * shape associated with this object (not null)
+ */
protected CollisionShape collisionShape;
+ /**
+ * collideWithGroups bitmask that represents "no groups"
+ */
public static final int COLLISION_GROUP_NONE = 0x00000000;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #1
+ */
public static final int COLLISION_GROUP_01 = 0x00000001;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #2
+ */
public static final int COLLISION_GROUP_02 = 0x00000002;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #3
+ */
public static final int COLLISION_GROUP_03 = 0x00000004;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #4
+ */
public static final int COLLISION_GROUP_04 = 0x00000008;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #5
+ */
public static final int COLLISION_GROUP_05 = 0x00000010;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #6
+ */
public static final int COLLISION_GROUP_06 = 0x00000020;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #7
+ */
public static final int COLLISION_GROUP_07 = 0x00000040;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #8
+ */
public static final int COLLISION_GROUP_08 = 0x00000080;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #9
+ */
public static final int COLLISION_GROUP_09 = 0x00000100;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #10
+ */
public static final int COLLISION_GROUP_10 = 0x00000200;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #11
+ */
public static final int COLLISION_GROUP_11 = 0x00000400;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #12
+ */
public static final int COLLISION_GROUP_12 = 0x00000800;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #13
+ */
public static final int COLLISION_GROUP_13 = 0x00001000;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #14
+ */
public static final int COLLISION_GROUP_14 = 0x00002000;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #15
+ */
public static final int COLLISION_GROUP_15 = 0x00004000;
+ /**
+ * collisionGroup/collideWithGroups bitmask that represents group #16
+ */
public static final int COLLISION_GROUP_16 = 0x00008000;
+ /**
+ * collision group to which this physics object belongs (default=group #1)
+ */
protected int collisionGroup = 0x00000001;
+ /**
+ * collision groups with which this object can collide (default=only group
+ * #1)
+ */
protected int collisionGroupsMask = 0x00000001;
private Object userObject;
/**
- * Sets a CollisionShape to this physics object, note that the object should
- * not be in the physics space when adding a new collision shape as it is rebuilt
- * on the physics side.
- * @param collisionShape the CollisionShape to set
+ * Apply the specified CollisionShape to this object. Note that the object
+ * should not be in any physics space while changing shape; the object gets
+ * rebuilt on the physics side.
+ *
+ * @param collisionShape the shape to apply (not null, alias created)
*/
public void setCollisionShape(CollisionShape collisionShape) {
this.collisionShape = collisionShape;
}
/**
- * @return the CollisionShape of this PhysicsNode, to be able to reuse it with
- * other physics nodes (increases performance)
+ * Access the shape of this physics object.
+ *
+ * @return the pre-existing instance, which can then be applied to other
+ * physics objects (increases performance)
*/
public CollisionShape getCollisionShape() {
return collisionShape;
}
/**
- * Returns the collision group for this collision shape
- * @return The collision group
+ * Read the collision group for this physics object.
+ *
+ * @return the collision group (bit mask with exactly one bit set)
*/
public int getCollisionGroup() {
return collisionGroup;
}
/**
- * Sets the collision group number for this physics object.
+ * Groups are represented by integer bit masks with exactly 1 bit set.
+ * Pre-made variables are available in PhysicsCollisionObject. By default,
+ * physics objects are in COLLISION_GROUP_01.
+ *
+ * Two objects can collide only if one of them has the collisionGroup of the
+ * other in its collideWithGroups set.
+ *
+ * @param collisionGroup the collisionGroup to apply (bit mask with exactly
+ * 1 bit set)
*/
public void setCollisionGroup(int collisionGroup) {
this.collisionGroup = collisionGroup;
@@ -108,10 +188,12 @@ public abstract class PhysicsCollisionObject implements Savable {
}
/**
- * Add a group that this object will collide with.
+ * Collision shapes include BoxCollisionShape and CapsuleCollisionShape. As
+ * suggested in the Bullet manual, a single collision shape can be shared among
+ * multiple collision objects.
+ *
* @author normenhansen
*/
public abstract class CollisionShape implements Savable {
+ /**
+ * unique identifier of the btCollisionShape
+ *
+ * Constructors are responsible for setting this to a non-zero value. After
+ * that, the id never changes.
+ */
protected long objectId = 0;
+ /**
+ * copy of scaling factors: one for each local axis (default=1,1,1)
+ */
protected Vector3f scale = new Vector3f(1, 1, 1);
+ /**
+ * copy of collision margin (in physics-space units, >0, default=0)
+ */
protected float margin = 0.0f;
public CollisionShape() {
@@ -70,7 +86,9 @@ public abstract class CollisionShape implements Savable {
// private native void calculateLocalInertia(long objectId, long shapeId, float mass);
/**
- * used internally
+ * Read the id of the btCollisionShape.
+ *
+ * @return the unique identifier (not zero)
*/
public long getObjectId() {
return objectId;
@@ -83,21 +101,52 @@ public abstract class CollisionShape implements Savable {
this.objectId = id;
}
+ /**
+ * Alter the scaling factors of this shape. CAUTION: Not all shapes can be
+ * scaled.
+ *
+ * Note that if the shape is shared (between collision objects and/or
+ * compound shapes) changes can have unintended consequences.
+ *
+ * @param scale the desired scaling factor for each local axis (not null, no
+ * negative component, unaffected, default=1,1,1)
+ */
public void setScale(Vector3f scale) {
this.scale.set(scale);
setLocalScaling(objectId, scale);
}
-
+ /**
+ * Access the scaling factors.
+ *
+ * @return the pre-existing vector (not null)
+ */
public Vector3f getScale() {
return scale;
}
+ /**
+ * Read the collision margin for this shape.
+ *
+ * @return the margin distance (in physics-space units, ≥0)
+ */
public float getMargin() {
return getMargin(objectId);
}
private native float getMargin(long objectId);
+ /**
+ * Alter the collision margin of this shape. CAUTION: Margin is applied
+ * differently, depending on the type of shape. Generally the collision
+ * margin expands the object, creating a gap. Don't set the collision margin
+ * to zero.
+ *
+ * Note that if the shape is shared (between collision objects and/or
+ * compound shapes) changes can have unintended consequences.
+ *
+ * @param margin the desired margin distance (in physics-space units, >0,
+ * default=0)
+ */
public void setMargin(float margin) {
setMargin(objectId, margin);
this.margin = margin;
@@ -107,18 +156,37 @@ public abstract class CollisionShape implements Savable {
private native void setMargin(long objectId, float margin);
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
OutputCapsule capsule = ex.getCapsule(this);
capsule.write(scale, "scale", new Vector3f(1, 1, 1));
capsule.write(getMargin(), "margin", 0.0f);
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
+ @Override
public void read(JmeImporter im) throws IOException {
InputCapsule capsule = im.getCapsule(this);
this.scale = (Vector3f) capsule.readSavable("scale", new Vector3f(1, 1, 1));
this.margin = capsule.readFloat("margin", 0.0f);
}
+ /**
+ * Finalize this shape just before it is destroyed. Should be invoked only
+ * by a subclass or by the garbage collector.
+ *
+ * @throws Throwable ignored by the garbage collector
+ */
@Override
protected void finalize() throws Throwable {
super.finalize();
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CompoundCollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CompoundCollisionShape.java
index b2321afdc..254006676 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CompoundCollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CompoundCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -46,23 +46,33 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * A CompoundCollisionShape allows combining multiple base shapes
- * to generate a more sophisticated shape.
+ * A collision shape formed by combining convex child shapes, based on Bullet's
+ * btCompoundShape.
+ *
* @author normenhansen
*/
public class CompoundCollisionShape extends CollisionShape {
+ /**
+ * children of this shape
+ */
protected ArrayList
+ * This is much more efficient than a regular mesh, but it has a couple
+ * limitations:
+ *
+ * A Java reference must persist after createShape() completes, or else the
+ * buffer might get garbage collected.
+ */
protected ByteBuffer bbuf;
// protected FloatBuffer fbuf;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public HeightfieldCollisionShape() {
}
+ /**
+ * Instantiate a new shape for the specified height map.
+ *
+ * @param heightmap (not null, length≥4, length a perfect square)
+ */
public HeightfieldCollisionShape(float[] heightmap) {
createCollisionHeightfield(heightmap, Vector3f.UNIT_XYZ);
}
+ /**
+ * Instantiate a new shape for the specified height map and scale vector.
+ *
+ * @param heightmap (not null, length≥4, length a perfect square)
+ * @param scale (not null, no negative component, unaffected, default=1,1,1)
+ */
public HeightfieldCollisionShape(float[] heightmap, Vector3f scale) {
createCollisionHeightfield(heightmap, scale);
}
@@ -120,6 +156,9 @@ public class HeightfieldCollisionShape extends CollisionShape {
createShape();
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
protected void createShape() {
bbuf = BufferUtils.createByteBuffer(heightfieldData.length * 4);
// fbuf = bbuf.asFloatBuffer();//FloatBuffer.wrap(heightfieldData);
@@ -138,11 +177,22 @@ public class HeightfieldCollisionShape extends CollisionShape {
private native long createShape(int heightStickWidth, int heightStickLength, ByteBuffer heightfieldData, float heightScale, float minHeight, float maxHeight, int upAxis, boolean flipQuadEdges);
+ /**
+ * Does nothing.
+ *
+ * @return null
+ */
public Mesh createJmeMesh() {
//TODO return Converter.convert(bulletMesh);
return null;
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
super.write(ex);
OutputCapsule capsule = ex.getCapsule(this);
@@ -156,6 +206,12 @@ public class HeightfieldCollisionShape extends CollisionShape {
capsule.write(flipQuadEdges, "flipQuadEdges", false);
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
super.read(im);
InputCapsule capsule = im.getCapsule(this);
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/HullCollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/HullCollisionShape.java
index db40eedac..d20e0e51e 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/HullCollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/HullCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -44,24 +44,52 @@ import java.nio.FloatBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;
+/**
+ * A convex hull collision shape based on Bullet's btConvexHullShape.
+ */
public class HullCollisionShape extends CollisionShape {
private float[] points;
// protected FloatBuffer fbuf;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public HullCollisionShape() {
}
+ /**
+ * Instantiate a collision shape based on the specified JME mesh. For best
+ * performance and stability, use the mesh should have no more than 100
+ * vertices.
+ *
+ * @param mesh a mesh on which to base the shape (not null, at least one
+ * vertex)
+ */
public HullCollisionShape(Mesh mesh) {
this.points = getPoints(mesh);
createShape();
}
+ /**
+ * Instantiate a collision shape based on the specified array of
+ * coordinates.
+ *
+ * @param points an array of coordinates on which to base the shape (not
+ * null, not empty, length a multiple of 3)
+ */
public HullCollisionShape(float[] points) {
this.points = points;
createShape();
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -70,6 +98,12 @@ public class HullCollisionShape extends CollisionShape {
capsule.write(points, "points", null);
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
@@ -89,6 +123,9 @@ public class HullCollisionShape extends CollisionShape {
createShape();
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
protected void createShape() {
// ObjectArrayList
+ *
* This constructor bypasses all copy logic normally used, this allows for
- * faster bullet shape generation when using procedurally generated Meshes.
- *
+ * faster Bullet shape generation when using procedurally generated Meshes.
*
* @param indices the raw index buffer
* @param vertices the raw vertex buffer
- * @param memoryOptimized use quantisize BVH, uses less memory, but slower
+ * @param memoryOptimized use quantized BVH, uses less memory, but slower
*/
public MeshCollisionShape(ByteBuffer indices, ByteBuffer vertices, boolean memoryOptimized) {
this.triangleIndexBase = indices;
@@ -153,6 +159,12 @@ public class MeshCollisionShape extends CollisionShape {
this.createShape(null);
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(final JmeExporter ex) throws IOException {
super.write(ex);
@@ -178,6 +190,12 @@ public class MeshCollisionShape extends CollisionShape {
}
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(final JmeImporter im) throws IOException {
super.read(im);
@@ -195,6 +213,9 @@ public class MeshCollisionShape extends CollisionShape {
createShape(nativeBvh);
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
private void createShape(byte bvh[]) {
boolean buildBvh=bvh==null||bvh.length==0;
this.meshId = NativeMeshUtil.createTriangleIndexVertexArray(this.triangleIndexBase, this.vertexBase, this.numTriangles, this.numVertices, this.vertexStride, this.triangleIndexStride);
@@ -216,6 +237,12 @@ public class MeshCollisionShape extends CollisionShape {
private native long createShape(boolean memoryOptimized, boolean buildBvt, long meshId);
+ /**
+ * Finalize this shape just before it is destroyed. Should be invoked only
+ * by a subclass or by the garbage collector.
+ *
+ * @throws Throwable ignored by the garbage collector
+ */
@Override
public void finalize() throws Throwable {
super.finalize();
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/PlaneCollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/PlaneCollisionShape.java
index caf654899..6b8bb88bb 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/PlaneCollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/PlaneCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -42,34 +42,60 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
+ * A planar collision shape based on Bullet's btStaticPlaneShape.
*
* @author normenhansen
*/
public class PlaneCollisionShape extends CollisionShape{
+ /**
+ * description of the plane
+ */
private Plane plane;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public PlaneCollisionShape() {
}
/**
- * Creates a plane Collision shape
- * @param plane the plane that defines the shape
+ * Instantiate a plane shape defined by the specified plane.
+ *
+ * @param plane the desired plane (not null, alias created)
*/
public PlaneCollisionShape(Plane plane) {
this.plane = plane;
createShape();
}
+ /**
+ * Access the defining plane.
+ *
+ * @return the pre-existing instance (not null)
+ */
public final Plane getPlane() {
return plane;
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
super.write(ex);
OutputCapsule capsule = ex.getCapsule(this);
capsule.write(plane, "collisionPlane", new Plane());
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
super.read(im);
InputCapsule capsule = im.getCapsule(this);
@@ -77,6 +103,9 @@ public class PlaneCollisionShape extends CollisionShape{
createShape();
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
protected void createShape() {
objectId = createShape(plane.getNormal(), plane.getConstant());
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Shape {0}", Long.toHexString(objectId));
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SimplexCollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SimplexCollisionShape.java
index fff1c7058..6a538a1c0 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SimplexCollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SimplexCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -41,16 +41,33 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * A simple point, line, triangle or quad collisionShape based on one to four points-
+ * A simple point, line-segment, triangle, or tetrahedron collision shape based
+ * on Bullet's btBU_Simplex1to4.
+ *
* @author normenhansen
*/
public class SimplexCollisionShape extends CollisionShape {
+ /**
+ * vertex positions
+ */
private Vector3f vector1, vector2, vector3, vector4;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public SimplexCollisionShape() {
}
+ /**
+ * Instantiate a tetrahedral collision shape based on the specified points.
+ *
+ * @param point1 the coordinates of 1st point (not null, alias created)
+ * @param point2 the coordinates of 2nd point (not null, alias created)
+ * @param point3 the coordinates of 3rd point (not null, alias created)
+ * @param point4 the coordinates of 4th point (not null, alias created)
+ */
public SimplexCollisionShape(Vector3f point1, Vector3f point2, Vector3f point3, Vector3f point4) {
vector1 = point1;
vector2 = point2;
@@ -59,6 +76,13 @@ public class SimplexCollisionShape extends CollisionShape {
createShape();
}
+ /**
+ * Instantiate a triangular collision shape based on the specified points.
+ *
+ * @param point1 the coordinates of 1st point (not null, alias created)
+ * @param point2 the coordinates of 2nd point (not null, alias created)
+ * @param point3 the coordinates of 3rd point (not null, alias created)
+ */
public SimplexCollisionShape(Vector3f point1, Vector3f point2, Vector3f point3) {
vector1 = point1;
vector2 = point2;
@@ -66,17 +90,34 @@ public class SimplexCollisionShape extends CollisionShape {
createShape();
}
+ /**
+ * Instantiate a line-segment collision shape based on the specified points.
+ *
+ * @param point1 the coordinates of 1st point (not null, alias created)
+ * @param point2 the coordinates of 2nd point (not null, alias created)
+ */
public SimplexCollisionShape(Vector3f point1, Vector3f point2) {
vector1 = point1;
vector2 = point2;
createShape();
}
+ /**
+ * Instantiate a point collision shape based on the specified points.
+ *
+ * @param point1 the coordinates of point (not null, alias created)
+ */
public SimplexCollisionShape(Vector3f point1) {
vector1 = point1;
createShape();
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
super.write(ex);
OutputCapsule capsule = ex.getCapsule(this);
@@ -86,6 +127,12 @@ public class SimplexCollisionShape extends CollisionShape {
capsule.write(vector4, "simplexPoint4", null);
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
super.read(im);
InputCapsule capsule = im.getCapsule(this);
@@ -96,6 +143,9 @@ public class SimplexCollisionShape extends CollisionShape {
createShape();
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
protected void createShape() {
if (vector4 != null) {
objectId = createShape(vector1, vector2, vector3, vector4);
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SphereCollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SphereCollisionShape.java
index 4ba6152c9..dd4228e37 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SphereCollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/SphereCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -41,35 +41,62 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * Basic sphere collision shape
+ * A spherical collision shape based on Bullet's btSphereShape. These shapes
+ * have no margin and cannot be scaled.
+ *
* @author normenhansen
*/
public class SphereCollisionShape extends CollisionShape {
+ /**
+ * copy of radius (≥0)
+ */
protected float radius;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public SphereCollisionShape() {
}
/**
- * creates a SphereCollisionShape with the given radius
- * @param radius
+ * Instantiate a sphere shape with the specified radius.
+ *
+ * @param radius the desired radius (≥0)
*/
public SphereCollisionShape(float radius) {
this.radius = radius;
createShape();
}
+ /**
+ * Read the radius of the sphere.
+ *
+ * @return the radius (≥0)
+ */
public float getRadius() {
return radius;
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
super.write(ex);
OutputCapsule capsule = ex.getCapsule(this);
capsule.write(radius, "radius", 0.5f);
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
super.read(im);
InputCapsule capsule = im.getCapsule(this);
@@ -78,7 +105,11 @@ public class SphereCollisionShape extends CollisionShape {
}
/**
- * WARNING - CompoundCollisionShape scaling has no effect.
+ * Alter the scaling factors of this shape. Scaling is disabled
+ * for sphere shapes.
+ *
+ * @param scale the desired scaling factor for each local axis (not null, no
+ * negative component, unaffected, default=1,1,1)
*/
@Override
public void setScale(Vector3f scale) {
@@ -87,6 +118,9 @@ public class SphereCollisionShape extends CollisionShape {
}
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
protected void createShape() {
objectId = createShape(radius);
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Shape {0}", Long.toHexString(objectId));
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/ConeJoint.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/ConeJoint.java
index 4284e7ad3..d3ec3534a 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/ConeJoint.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/ConeJoint.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -43,10 +43,13 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * From bullet manual:
+ * From the Bullet manual:
+ * From the Bullet manual: PhysicsJoint - Basic Phyiscs Joint
+ * Joints include ConeJoint, HingeJoint, Point2PointJoint, and SixDofJoint.
+ *
* @author normenhansen
*/
public abstract class PhysicsJoint implements Savable {
+ /**
+ * Unique identifier of the Bullet constraint. Constructors are responsible
+ * for setting this to a non-zero value. After that, the id never changes.
+ */
protected long objectId = 0;
+ /**
+ * one of the connected rigid bodies
+ */
protected PhysicsRigidBody nodeA;
+ /**
+ * the other connected rigid body
+ */
protected PhysicsRigidBody nodeB;
+ /**
+ * local offset of this joint's connection point in node A
+ */
protected Vector3f pivotA;
+ /**
+ * local offset of this joint's connection point in node B
+ */
protected Vector3f pivotB;
protected boolean collisionBetweenLinkedBodys = true;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public PhysicsJoint() {
}
/**
- * @param pivotA local translation of the joint connection point in node A
- * @param pivotB local translation of the joint connection point in node B
+ * Instantiate a PhysicsJoint. To be effective, the joint must be added to
+ * the physics space of the two bodies. Also, the bodies must be dynamic and
+ * distinct.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
+ * @param pivotA local offset of the joint connection point in node A (not
+ * null, alias created)
+ * @param pivotB local offset of the joint connection point in node B (not
+ * null, alias created)
*/
public PhysicsJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB) {
this.nodeA = nodeA;
@@ -67,6 +102,11 @@ public abstract class PhysicsJoint implements Savable {
nodeB.addJoint(this);
}
+ /**
+ * Read the magnitude of the applied impulse.
+ *
+ * @return impulse
+ */
public float getAppliedImpulse() {
return getAppliedImpulse(objectId);
}
@@ -74,52 +114,84 @@ public abstract class PhysicsJoint implements Savable {
private native float getAppliedImpulse(long objectId);
/**
- * @return the constraint
+ * Read the id of the Bullet constraint.
+ *
+ * @return the unique identifier (not zero)
*/
public long getObjectId() {
return objectId;
}
/**
- * @return the collisionBetweenLinkedBodys
+ * Test whether collisions are allowed between the linked bodies.
+ *
+ * @return true if collision are allowed, otherwise false
*/
public boolean isCollisionBetweenLinkedBodys() {
return collisionBetweenLinkedBodys;
}
/**
- * toggles collisions between linked bodys
+ * From the Bullet manual:
+ * From the Bullet manual:
+ * For each axis:
+ * From the Bullet manual:
+ * For each axis:
+ * From the Bullet manual:
+ * This addresses the issue of fast objects passing through other objects
+ * with no collision detected.
+ *
+ * @param threshold the desired threshold velocity (>0) or zero to
+ * disable CCD (default=0)
+ */
public void setCcdMotionThreshold(float threshold) {
setCcdMotionThreshold(objectId, threshold);
}
private native void setCcdMotionThreshold(long objectId, float threshold);
+ /**
+ * Read the radius of the sphere used for continuous collision detection
+ * (CCD).
+ *
+ * @return radius (≥0)
+ */
public float getCcdSweptSphereRadius() {
return getCcdSweptSphereRadius(objectId);
}
private native float getCcdSweptSphereRadius(long objectId);
+ /**
+ * Calculate this character's continuous collision detection (CCD) motion
+ * threshold.
+ *
+ * @return the threshold velocity (≥0)
+ */
public float getCcdMotionThreshold() {
return getCcdMotionThreshold(objectId);
}
private native float getCcdMotionThreshold(long objectId);
+ /**
+ * Calculate the square of this character's continuous collision detection
+ * (CCD) motion threshold.
+ *
+ * @return the threshold velocity squared (≥0)
+ */
public float getCcdSquareMotionThreshold() {
return getCcdSquareMotionThreshold(objectId);
}
@@ -409,14 +625,25 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
/**
* used internally
+ *
+ * @return the Bullet id
*/
public long getControllerId() {
return characterId;
}
+ /**
+ * Has no effect.
+ */
public void destroy() {
}
+ /**
+ * Serialize this character, for example when saving to a J3O file.
+ *
+ * @param e exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter e) throws IOException {
super.write(e);
@@ -432,6 +659,13 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
capsule.write(getPhysicsLocation(new Vector3f()), "physicsLocation", new Vector3f());
}
+ /**
+ * De-serialize this character from the specified importer, for example when
+ * loading from a J3O file.
+ *
+ * @param e importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter e) throws IOException {
super.read(e);
@@ -448,6 +682,12 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
setPhysicsLocation((Vector3f) capsule.readSavable("physicsLocation", new Vector3f()));
}
+ /**
+ * Finalize this physics character just before it is destroyed. Should be
+ * invoked only by a subclass or by the garbage collector.
+ *
+ * @throws Throwable ignored by the garbage collector
+ */
@Override
protected void finalize() throws Throwable {
super.finalize();
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsGhostObject.java b/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsGhostObject.java
index 052e280e4..acb3752e6 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsGhostObject.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsGhostObject.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -48,11 +48,14 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
+ * A collision object for intangibles, based on Bullet's
+ * btPairCachingGhostObject. This is useful for creating a character controller,
+ * collision sensors/triggers, explosions etc.
+ *
* From Bullet manual:
+ * This addresses the issue of fast objects passing through other objects
+ * with no collision detected.
+ *
+ * @param threshold the desired threshold value (squared velocity, >0) or
+ * zero to disable CCD (default=0)
+ */
public void setCcdMotionThreshold(float threshold) {
setCcdMotionThreshold(objectId, threshold);
}
private native void setCcdMotionThreshold(long objectId, float threshold);
+ /**
+ * Read the radius of the sphere used for continuous collision detection
+ * (CCD).
+ *
+ * @return radius (≥0)
+ */
public float getCcdSweptSphereRadius() {
return getCcdSweptSphereRadius(objectId);
}
private native float getCcdSweptSphereRadius(long objectId);
+ /**
+ * Read the continuous collision detection (CCD) motion threshold for this
+ * object.
+ *
+ * @return threshold value (squared velocity, ≥0)
+ */
public float getCcdMotionThreshold() {
return getCcdMotionThreshold(objectId);
}
private native float getCcdMotionThreshold(long objectId);
+ /**
+ * Read the CCD square motion threshold for this object.
+ *
+ * @return threshold value (≥0)
+ */
public float getCcdSquareMotionThreshold() {
return getCcdSquareMotionThreshold(objectId);
}
private native float getCcdSquareMotionThreshold(long objectId);
+ /**
+ * Serialize this object, for example when saving to a J3O file.
+ *
+ * @param e exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter e) throws IOException {
super.write(e);
@@ -288,6 +382,13 @@ public class PhysicsGhostObject extends PhysicsCollisionObject {
capsule.write(getCcdSweptSphereRadius(), "ccdSweptSphereRadius", 0);
}
+ /**
+ * De-serialize this object from the specified importer, for example when
+ * loading from a J3O file.
+ *
+ * @param e importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter e) throws IOException {
super.read(e);
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsRigidBody.java b/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsRigidBody.java
index 84c16f831..2cbbf3c42 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsRigidBody.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsRigidBody.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@
package com.jme3.bullet.objects;
import com.jme3.bullet.PhysicsSpace;
+import com.jme3.bullet.collision.CollisionFlag;
import com.jme3.bullet.collision.PhysicsCollisionObject;
import com.jme3.bullet.collision.shapes.CollisionShape;
import com.jme3.bullet.collision.shapes.MeshCollisionShape;
@@ -51,29 +52,55 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * PhysicsRigidBody - Basic physics object
+ * In kinematic mode, the body is not influenced by physics but can affect
+ * other physics objects. Its kinetic force is calculated based on its
+ * movement and weight.
+ *
+ * @param kinematic true→set kinematic mode, false→set
+ * dynamic/static mode (default=false)
*/
public void setKinematic(boolean kinematic) {
this.kinematic = kinematic;
@@ -276,10 +357,41 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setKinematic(long objectId, boolean kinematic);
+ /**
+ * Test whether this body is in kinematic mode.
+ *
+ * In kinematic mode, the body is not influenced by physics but can affect
+ * other physics objects. Its kinetic force is calculated based on its
+ * movement and weight.
+ *
+ * @return true if in kinematic mode, otherwise false (dynamic/static mode)
+ */
public boolean isKinematic() {
return kinematic;
}
+ /**
+ * Enable/disable this body's contact response.
+ *
+ * @param responsive true to respond to contacts, false to ignore them
+ * (default=true)
+ */
+ public void setContactResponse(boolean responsive) {
+ int flags = getCollisionFlags(objectId);
+ if (responsive) {
+ flags &= ~CollisionFlag.NO_CONTACT_RESPONSE;
+ } else {
+ flags |= CollisionFlag.NO_CONTACT_RESPONSE;
+ }
+ setCollisionFlags(objectId, flags);
+ }
+
+ /**
+ * Alter the radius of the swept sphere used for continuous collision
+ * detection (CCD).
+ *
+ * @param radius the desired radius (≥0, default=0)
+ */
public void setCcdSweptSphereRadius(float radius) {
setCcdSweptSphereRadius(objectId, radius);
}
@@ -287,9 +399,14 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setCcdSweptSphereRadius(long objectId, float radius);
/**
- * Sets the amount of motion that has to happen in one physics tick to trigger the continuous motion detection
+ * This addresses the issue of fast objects passing through other objects
+ * with no collision detected.
+ *
+ * @param threshold the desired threshold velocity (>0) or zero to
+ * disable CCD (default=0)
*/
public void setCcdMotionThreshold(float threshold) {
setCcdMotionThreshold(objectId, threshold);
@@ -297,31 +414,56 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setCcdMotionThreshold(long objectId, float threshold);
+ /**
+ * Read the radius of the swept sphere used for continuous collision
+ * detection (CCD).
+ *
+ * @return radius (≥0)
+ */
public float getCcdSweptSphereRadius() {
return getCcdSweptSphereRadius(objectId);
}
private native float getCcdSweptSphereRadius(long objectId);
+ /**
+ * Calculate this body's continuous collision detection (CCD) motion
+ * threshold.
+ *
+ * @return the threshold velocity (≥0)
+ */
public float getCcdMotionThreshold() {
return getCcdMotionThreshold(objectId);
}
private native float getCcdMotionThreshold(long objectId);
+ /**
+ * Calculate the square of this body's continuous collision detection (CCD)
+ * motion threshold.
+ *
+ * @return the threshold velocity squared (≥0)
+ */
public float getCcdSquareMotionThreshold() {
return getCcdSquareMotionThreshold(objectId);
}
private native float getCcdSquareMotionThreshold(long objectId);
+ /**
+ * Read this body's mass.
+ *
+ * @return the mass (>0) or zero for a static body
+ */
public float getMass() {
return mass;
}
/**
- * Sets the mass of this PhysicsRigidBody, objects with mass=0 are static.
- * @param mass
+ * Alter this body's mass. Bodies with mass=0 are static. For dynamic
+ * bodies, it is best to keep the mass around 1.
+ *
+ * @param mass the desired mass (>0) or 0 for a static body (default=1)
*/
public void setMass(float mass) {
this.mass = mass;
@@ -344,10 +486,23 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native long updateMassProps(long objectId, long collisionShapeId, float mass);
+ /**
+ * Copy this body's gravitational acceleration.
+ *
+ * @return a new acceleration vector (in physics-space coordinates, not
+ * null)
+ */
public Vector3f getGravity() {
return getGravity(null);
}
+ /**
+ * Copy this body's gravitational acceleration.
+ *
+ * @param gravity storage for the result (modified if not null)
+ * @return an acceleration vector (in physics-space coordinates, either the
+ * provided storage or a new vector, not null)
+ */
public Vector3f getGravity(Vector3f gravity) {
if (gravity == null) {
gravity = new Vector3f();
@@ -359,16 +514,23 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void getGravity(long objectId, Vector3f gravity);
/**
- * Set the local gravity of this PhysicsRigidBody
+ * Invoke this after adding the body to a PhysicsSpace. Adding a body to a
+ * PhysicsSpace alters its gravity.
+ *
+ * @param gravity the desired acceleration vector (not null, unaffected)
*/
public void setGravity(Vector3f gravity) {
setGravity(objectId, gravity);
}
private native void setGravity(long objectId, Vector3f gravity);
+ /**
+ * Read this body's friction.
+ *
+ * @return friction value
+ */
public float getFriction() {
return getFriction(objectId);
}
@@ -376,8 +538,9 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native float getFriction(long objectId);
/**
- * Sets the friction of this physics object
- * @param friction the friction of this physics object
+ * Alter this body's friction.
+ *
+ * @param friction the desired friction value (default=0.5)
*/
public void setFriction(float friction) {
setFriction(objectId, friction);
@@ -385,6 +548,12 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setFriction(long objectId, float friction);
+ /**
+ * Alter this body's damping.
+ *
+ * @param linearDamping the desired linear damping value (default=0)
+ * @param angularDamping the desired angular damping value (default=0)
+ */
public void setDamping(float linearDamping, float angularDamping) {
setDamping(objectId, linearDamping, angularDamping);
}
@@ -400,27 +569,52 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
//
// private native void setRestitution(long objectId, float factor);
//
+ /**
+ * Alter this body's linear damping.
+ *
+ * @param linearDamping the desired linear damping value (default=0)
+ */
public void setLinearDamping(float linearDamping) {
setDamping(objectId, linearDamping, getAngularDamping());
}
-
+
+ /**
+ * Alter this body's angular damping.
+ *
+ * @param angularDamping the desired angular damping value (default=0)
+ */
public void setAngularDamping(float angularDamping) {
setAngularDamping(objectId, angularDamping);
}
private native void setAngularDamping(long objectId, float factor);
+ /**
+ * Read this body's linear damping.
+ *
+ * @return damping value
+ */
public float getLinearDamping() {
return getLinearDamping(objectId);
}
private native float getLinearDamping(long objectId);
+ /**
+ * Read this body's angular damping.
+ *
+ * @return damping value
+ */
public float getAngularDamping() {
return getAngularDamping(objectId);
}
private native float getAngularDamping(long objectId);
+ /**
+ * Read this body's restitution (bounciness).
+ *
+ * @return restitution value
+ */
public float getRestitution() {
return getRestitution(objectId);
}
@@ -428,8 +622,10 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native float getRestitution(long objectId);
/**
- * The "bouncyness" of the PhysicsRigidBody, best performance if restitution=0
- * @param restitution
+ * Alter this body's restitution (bounciness). For best performance, set
+ * restitution=0.
+ *
+ * @param restitution the desired value (default=0)
*/
public void setRestitution(float restitution) {
setRestitution(objectId, restitution);
@@ -438,8 +634,9 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setRestitution(long objectId, float factor);
/**
- * Get the current angular velocity of this PhysicsRigidBody
- * @return the current linear velocity
+ * Copy this body's angular velocity.
+ *
+ * @return a new velocity vector (in physics-space coordinates, not null)
*/
public Vector3f getAngularVelocity() {
Vector3f vec = new Vector3f();
@@ -450,16 +647,19 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void getAngularVelocity(long objectId, Vector3f vec);
/**
- * Get the current angular velocity of this PhysicsRigidBody
- * @param vec the vector to store the velocity in
+ * Copy this body's angular velocity.
+ *
+ * @param vec storage for the result (in physics-space coordinates, not
+ * null, modified)
*/
public void getAngularVelocity(Vector3f vec) {
getAngularVelocity(objectId, vec);
}
/**
- * Sets the angular velocity of this PhysicsRigidBody
- * @param vec the angular velocity of this PhysicsRigidBody
+ * Alter this body's angular velocity.
+ *
+ * @param vec the desired angular velocity vector (not null, unaffected)
*/
public void setAngularVelocity(Vector3f vec) {
setAngularVelocity(objectId, vec);
@@ -469,8 +669,9 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setAngularVelocity(long objectId, Vector3f vec);
/**
- * Get the current linear velocity of this PhysicsRigidBody
- * @return the current linear velocity
+ * Copy the linear velocity of this body's center of mass.
+ *
+ * @return a new velocity vector (in physics-space coordinates, not null)
*/
public Vector3f getLinearVelocity() {
Vector3f vec = new Vector3f();
@@ -481,16 +682,19 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void getLinearVelocity(long objectId, Vector3f vec);
/**
- * Get the current linear velocity of this PhysicsRigidBody
- * @param vec the vector to store the velocity in
+ * Copy the linear velocity of this body's center of mass.
+ *
+ * @param vec storage for the result (in physics-space coordinates, not
+ * null, modified)
*/
public void getLinearVelocity(Vector3f vec) {
getLinearVelocity(objectId, vec);
}
/**
- * Sets the linear velocity of this PhysicsRigidBody
- * @param vec the linear velocity of this PhysicsRigidBody
+ * Alter the linear velocity of this body's center of mass.
+ *
+ * @param vec the desired velocity vector (not null)
*/
public void setLinearVelocity(Vector3f vec) {
setLinearVelocity(objectId, vec);
@@ -500,10 +704,13 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setLinearVelocity(long objectId, Vector3f vec);
/**
- * Apply a force to the PhysicsRigidBody, only applies force if the next physics update call
- * updates the physics space.
+ * To apply an impulse, use applyImpulse, use applyContinuousForce to apply
+ * continuous force.
+ *
+ * @param force the force (not null, unaffected)
* @param location the location of the force
*/
public void applyForce(Vector3f force, Vector3f location) {
@@ -514,11 +721,13 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void applyForce(long objectId, Vector3f force, Vector3f location);
/**
- * Apply a force to the PhysicsRigidBody, only applies force if the next physics update call
- * updates the physics space.
+ * To apply an impulse, use
+ * {@link #applyImpulse(com.jme3.math.Vector3f, com.jme3.math.Vector3f)}.
+ *
+ * @param force the force (not null, unaffected)
*/
public void applyCentralForce(Vector3f force) {
applyCentralForce(objectId, force);
@@ -528,11 +737,13 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void applyCentralForce(long objectId, Vector3f force);
/**
- * Apply a force to the PhysicsRigidBody, only applies force if the next physics update call
- * updates the physics space.
+ * To apply an impulse, use
+ * {@link #applyImpulse(com.jme3.math.Vector3f, com.jme3.math.Vector3f)}.
+ *
+ * @param torque the torque (not null, unaffected)
*/
public void applyTorque(Vector3f torque) {
applyTorque(objectId, torque);
@@ -542,9 +753,10 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void applyTorque(long objectId, Vector3f vec);
/**
- * Apply an impulse to the PhysicsRigidBody in the next physics update.
- * @param impulse applied impulse
- * @param rel_pos location relative to object
+ * Apply an impulse to the body the next physics update.
+ *
+ * @param impulse applied impulse (not null, unaffected)
+ * @param rel_pos location relative to object (not null, unaffected)
*/
public void applyImpulse(Vector3f impulse, Vector3f rel_pos) {
applyImpulse(objectId, impulse, rel_pos);
@@ -554,8 +766,9 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void applyImpulse(long objectId, Vector3f impulse, Vector3f rel_pos);
/**
- * Apply a torque impulse to the PhysicsRigidBody in the next physics update.
- * @param vec
+ * Apply a torque impulse to the body in the next physics update.
+ *
+ * @param vec the torque to apply
*/
public void applyTorqueImpulse(Vector3f vec) {
applyTorqueImpulse(objectId, vec);
@@ -565,8 +778,7 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void applyTorqueImpulse(long objectId, Vector3f vec);
/**
- * Clear all forces from the PhysicsRigidBody
- *
+ * Clear all forces acting on this body.
*/
public void clearForces() {
clearForces(objectId);
@@ -574,6 +786,14 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void clearForces(long objectId);
+ /**
+ * Apply the specified CollisionShape to this body.
+ *
+ * Note that the body should not be in any physics space while changing
+ * shape; the body gets rebuilt on the physics side.
+ *
+ * @param collisionShape the shape to apply (not null, alias created)
+ */
public void setCollisionShape(CollisionShape collisionShape) {
super.setCollisionShape(collisionShape);
if (collisionShape instanceof MeshCollisionShape && mass != 0) {
@@ -590,7 +810,7 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setCollisionShape(long objectId, long collisionShapeId);
/**
- * reactivates this PhysicsRigidBody when it has been deactivated because it was not moving
+ * Reactivates this body if it has been deactivated due to lack of motion.
*/
public void activate() {
activate(objectId);
@@ -598,6 +818,11 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void activate(long objectId);
+ /**
+ * Test whether this body has been deactivated due to lack of motion.
+ *
+ * @return true if still active, false if deactivated
+ */
public boolean isActive() {
return isActive(objectId);
}
@@ -605,10 +830,13 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native boolean isActive(long objectId);
/**
- * sets the sleeping thresholds, these define when the object gets deactivated
- * to save ressources. Low values keep the object active when it barely moves
- * @param linear the linear sleeping threshold
- * @param angular the angular sleeping threshold
+ * Alter this body's sleeping thresholds.
+ *
+ * These thresholds determine when the body can be deactivated to save
+ * resources. Low values keep the body active when it barely moves.
+ *
+ * @param linear the desired linear sleeping threshold (≥0, default=0.8)
+ * @param angular the desired angular sleeping threshold (≥0, default=1)
*/
public void setSleepingThresholds(float linear, float angular) {
setSleepingThresholds(objectId, linear, angular);
@@ -616,36 +844,68 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void setSleepingThresholds(long objectId, float linear, float angular);
+ /**
+ * Alter this body's linear sleeping threshold.
+ *
+ * @param linearSleepingThreshold the desired threshold (≥0, default=0.8)
+ */
public void setLinearSleepingThreshold(float linearSleepingThreshold) {
setLinearSleepingThreshold(objectId, linearSleepingThreshold);
}
private native void setLinearSleepingThreshold(long objectId, float linearSleepingThreshold);
+ /**
+ * Alter this body's angular sleeping threshold.
+ *
+ * @param angularSleepingThreshold the desired threshold (≥0, default=1)
+ */
public void setAngularSleepingThreshold(float angularSleepingThreshold) {
setAngularSleepingThreshold(objectId, angularSleepingThreshold);
}
private native void setAngularSleepingThreshold(long objectId, float angularSleepingThreshold);
+ /**
+ * Read this body's linear sleeping threshold.
+ *
+ * @return the linear sleeping threshold (≥0)
+ */
public float getLinearSleepingThreshold() {
return getLinearSleepingThreshold(objectId);
}
private native float getLinearSleepingThreshold(long objectId);
+ /**
+ * Read this body's angular sleeping threshold.
+ *
+ * @return the angular sleeping threshold (≥0)
+ */
public float getAngularSleepingThreshold() {
return getAngularSleepingThreshold(objectId);
}
private native float getAngularSleepingThreshold(long objectId);
+ /**
+ * Read this body's angular factor for the X axis.
+ *
+ * @return the angular factor
+ */
public float getAngularFactor() {
return getAngularFactor(null).getX();
}
+ /**
+ * Copy this body's angular factors.
+ *
+ * @param store storage for the result (modified if not null)
+ * @return the angular factor for each axis (either the provided storage or
+ * new vector, not null)
+ */
public Vector3f getAngularFactor(Vector3f store) {
- // doing like this prevent from breaking the API
+ // Done this way to prevent breaking the API.
if (store == null) {
store = new Vector3f();
}
@@ -655,16 +915,33 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void getAngularFactor(long objectId, Vector3f vec);
+ /**
+ * Alter this body's angular factor.
+ *
+ * @param factor the desired angular factor for all axes (not null,
+ * unaffected, default=1)
+ */
public void setAngularFactor(float factor) {
setAngularFactor(objectId, new Vector3f(factor, factor, factor));
}
+ /**
+ * Alter this body's angular factors.
+ *
+ * @param factor the desired angular factor for each axis (not null,
+ * unaffected, default=(1,1,1))
+ */
public void setAngularFactor(Vector3f factor) {
setAngularFactor(objectId, factor);
}
private native void setAngularFactor(long objectId, Vector3f factor);
+ /**
+ * Copy this body's linear factors.
+ *
+ * @return the linear factor for each axis (not null)
+ */
public Vector3f getLinearFactor() {
Vector3f vec = new Vector3f();
getLinearFactor(objectId, vec);
@@ -673,6 +950,12 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
private native void getLinearFactor(long objectId, Vector3f vec);
+ /**
+ * Alter this body's linear factors.
+ *
+ * @param factor the desired linear factor for each axis (not null,
+ * unaffected, default=(1,1,1))
+ */
public void setLinearFactor(Vector3f factor) {
setLinearFactor(objectId, factor);
}
@@ -681,7 +964,9 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
/**
- * do not use manually, joints are added automatically
+ * Do not invoke directly! Joints are added automatically when created.
+ *
+ * @param joint the joint to add (not null)
*/
public void addJoint(PhysicsJoint joint) {
if (!joints.contains(joint)) {
@@ -690,21 +975,32 @@ public class PhysicsRigidBody extends PhysicsCollisionObject {
}
/**
- *
+ * Do not invoke directly! Joints are removed automatically when destroyed.
+ *
+ * @param joint the joint to remove (not null)
*/
public void removeJoint(PhysicsJoint joint) {
joints.remove(joint);
}
/**
- * Returns a list of connected joints. This list is only filled when
- * the PhysicsRigidBody is actually added to the physics space or loaded from disk.
- * @return list of active joints connected to this PhysicsRigidBody
+ * Access the list of joints connected with this body.
+ *
+ * This list is only filled when the PhysicsRigidBody is added to a physics
+ * space.
+ *
+ * @return the pre-existing list (not null)
*/
public List PhysicsVehicleNode - Special PhysicsNode that implements vehicle functions
- * From bullet manual:
+ * The entire vehicle is represented as a single rigidbody, the chassis. The
+ * collision detection of the wheels is approximated by ray casts, and the tire
+ * friction is a basic anisotropic friction model.
+ *
* @author normenhansen
*/
public class PhysicsVehicle extends PhysicsRigidBody {
+ /**
+ * Unique identifier of the btRaycastVehicle. The constructor sets this to a
+ * non-zero value.
+ */
protected long vehicleId = 0;
+ /**
+ * Unique identifier of the ray caster.
+ */
protected long rayCasterId = 0;
+ /**
+ * tuning parameters applied when a wheel is created
+ */
protected VehicleTuning tuning = new VehicleTuning();
+ /**
+ * list of wheels
+ */
protected ArrayList
+ * For better handling, increase the friction.
+ *
+ * @param frictionSlip the desired coefficient of friction between tyre and
+ * ground (0.8→realistic car, 10000→kart racer, default=10.5)
*/
public void setFrictionSlip(float frictionSlip) {
tuning.frictionSlip = frictionSlip;
}
/**
- * The coefficient of friction between the tyre and the ground.
- * Should be about 0.8 for realistic cars, but can increased for better handling.
- * Set large (10000.0) for kart racers
- * @param wheel
- * @param frictionSlip
+ * Alter the friction of the indexed wheel.
+ *
+ * For better handling, increase the friction.
+ *
+ * @param wheel the index of the wheel to modify (≥0)
+ * @param frictionSlip the desired coefficient of friction between tyre and
+ * ground (0.8→realistic car, 10000→kart racer)
*/
public void setFrictionSlip(int wheel, float frictionSlip) {
wheels.get(wheel).setFrictionSlip(frictionSlip);
}
/**
- * Reduces the rolling torque applied from the wheels that cause the vehicle to roll over.
- * This is a bit of a hack, but it's quite effective. 0.0 = no roll, 1.0 = physical behaviour.
- * If m_frictionSlip is too high, you'll need to reduce this to stop the vehicle rolling over.
- * You should also try lowering the vehicle's centre of mass
+ * Alter the roll influence of the indexed wheel.
+ *
+ * The roll-influence factor reduces (or magnifies) any torque contributed
+ * by the wheel that would tend to cause the vehicle to roll over. This is a
+ * bit of a hack, but it's quite effective.
+ *
+ * If the friction between the tyres and the ground is too high, you may
+ * reduce this factor to prevent the vehicle from rolling over. You should
+ * also try lowering the vehicle's center of mass.
+ *
+ * @param wheel the index of the wheel to modify (≥0)
+ * @param rollInfluence the desired roll-influence factor (0→no roll
+ * torque, 1→realistic behavior, default=1)
*/
public void setRollInfluence(int wheel, float rollInfluence) {
wheels.get(wheel).setRollInfluence(rollInfluence);
}
/**
- * @return the maxSuspensionTravelCm
+ * Read the initial maximum suspension travel distance for new wheels.
+ *
+ * @return the maximum distance the suspension can be compressed (in
+ * centimeters)
*/
public float getMaxSuspensionTravelCm() {
return tuning.maxSuspensionTravelCm;
}
/**
- * Use before adding wheels, this is the default used when adding wheels.
- * After adding the wheel, use direct wheel access.
+ * If the suspension cannot handle the vehicle's weight, increase this
+ * limit.
+ *
+ * @param maxSuspensionForce the desired maximum force per wheel
+ * (default=6000)
*/
public void setMaxSuspensionForce(float maxSuspensionForce) {
tuning.maxSuspensionForce = maxSuspensionForce;
}
/**
- * This vaue caps the maximum suspension force, raise this above the default 6000 if your suspension cannot
- * handle the weight of your vehcile.
- * @param wheel
- * @param maxSuspensionForce
+ * Alter the maximum suspension force for the specified wheel.
+ *
+ * If the suspension cannot handle the vehicle's weight, increase this
+ * limit.
+ *
+ * @param wheel the index of the wheel to modify (≥0)
+ * @param maxSuspensionForce the desired maximum force per wheel
+ * (default=6000)
*/
public void setMaxSuspensionForce(int wheel, float maxSuspensionForce) {
wheels.get(wheel).setMaxSuspensionForce(maxSuspensionForce);
}
/**
- * @return the suspensionCompression
+ * Read the initial damping (when the suspension is compressed) for new
+ * wheels.
+ *
+ * @return the damping coefficient
*/
public float getSuspensionCompression() {
return tuning.suspensionCompression;
}
/**
- * Use before adding wheels, this is the default used when adding wheels.
- * After adding the wheel, use direct wheel access.
+ * Set to k * 2 * FastMath.sqrt(m_suspensionStiffness) where k is the
+ * damping ratio:
+ *
+ * k = 0.0 undamped and bouncy, k = 1.0 critical damping, k between 0.1 and
+ * 0.3 are good values
+ *
+ * @param suspensionCompression the desired damping coefficient
+ * (default=0.83)
*/
public void setSuspensionCompression(float suspensionCompression) {
tuning.suspensionCompression = suspensionCompression;
}
/**
- * The damping coefficient for when the suspension is compressed.
- * Set to k * 2.0 * FastMath.sqrt(m_suspensionStiffness) so k is proportional to critical damping.
+ * Set to k * 2 * FastMath.sqrt(m_suspensionStiffness) where k is the
+ * damping ratio:
+ *
+ * k = 0.0 undamped and bouncy, k = 1.0 critical damping, k between 0.1 and
+ * 0.3 are good values
+ *
+ * @param wheel the index of the wheel to modify (≥0)
+ * @param suspensionCompression the desired damping coefficient
*/
public void setSuspensionCompression(int wheel, float suspensionCompression) {
wheels.get(wheel).setWheelsDampingCompression(suspensionCompression);
}
/**
- * @return the suspensionDamping
+ * Read the initial damping (when the suspension is expanded) for new
+ * wheels.
+ *
+ * @return the damping coefficient
*/
public float getSuspensionDamping() {
return tuning.suspensionDamping;
}
/**
- * Use before adding wheels, this is the default used when adding wheels.
- * After adding the wheel, use direct wheel access.
+ * Set to k * 2 * FastMath.sqrt(m_suspensionStiffness) where k is the
+ * damping ratio:
+ *
+ * k = 0.0 undamped and bouncy, k = 1.0 critical damping, k between 0.1 and
+ * 0.3 are good values
+ *
+ * @param suspensionDamping the desired damping coefficient (default=0.88)
*/
public void setSuspensionDamping(float suspensionDamping) {
tuning.suspensionDamping = suspensionDamping;
}
/**
- * The damping coefficient for when the suspension is expanding.
- * See the comments for setSuspensionCompression for how to set k.
- * @param wheel
- * @param suspensionDamping
+ * Alter the damping (when the suspension is expanded) for the indexed
+ * wheel.
+ *
+ * Set to k * 2 * FastMath.sqrt(m_suspensionStiffness) where k is the
+ * damping ratio:
+ *
+ * k = 0.0 undamped and bouncy, k = 1.0 critical damping, k between 0.1 and
+ * 0.3 are good values
+ *
+ * @param wheel the index of the wheel to modify (≥0)
+ * @param suspensionDamping the desired damping coefficient
*/
public void setSuspensionDamping(int wheel, float suspensionDamping) {
wheels.get(wheel).setWheelsDampingRelaxation(suspensionDamping);
}
/**
- * @return the suspensionStiffness
+ * Read the initial suspension stiffness for new wheels.
+ *
+ * @return the stiffness constant (10→off-road buggy, 50→sports
+ * car, 200→Formula-1 race car)
*/
public float getSuspensionStiffness() {
return tuning.suspensionStiffness;
}
/**
- * Use before adding wheels, this is the default used when adding wheels.
- * After adding the wheel, use direct wheel access.
+ * Set to k * 2 * FastMath.sqrt(m_suspensionStiffness) where k is the
+ * damping ratio:
+ *
+ * k = 0.0 undamped and bouncy, k = 1.0 critical damping, k between 0.1 and
+ * 0.3 are good values
+ *
+ * @param wheelsDampingRelaxation the desired damping (default=2.3)
*/
public void setWheelsDampingRelaxation(float wheelsDampingRelaxation) {
this.wheelsDampingRelaxation = wheelsDampingRelaxation;
applyInfo();
}
+ /**
+ * Read this wheel's damping when the suspension is compressed.
+ *
+ * @return the damping
+ */
public float getWheelsDampingCompression() {
return wheelsDampingCompression;
}
/**
- * the damping coefficient for when the suspension is compressed.
- * Set to k * 2.0 * FastMath.sqrt(m_suspensionStiffness) so k is proportional to critical damping.
+ * Set to k * 2 * FastMath.sqrt(m_suspensionStiffness) where k is the
+ * damping ratio:
+ *
+ * k = 0.0 undamped and bouncy, k = 1.0 critical damping, k between 0.1 and
+ * 0.3 are good values
+ *
+ * @param wheelsDampingCompression the desired damping (default=4.4)
*/
public void setWheelsDampingCompression(float wheelsDampingCompression) {
this.wheelsDampingCompression = wheelsDampingCompression;
applyInfo();
}
+ /**
+ * Read the friction between this wheel's tyre and the ground.
+ *
+ * @return the coefficient of friction
+ */
public float getFrictionSlip() {
return frictionSlip;
}
/**
- * the coefficient of friction between the tyre and the ground.
- * Should be about 0.8 for realistic cars, but can increased for better handling.
- * Set large (10000.0) for kart racers
- * @param frictionSlip
+ * Alter the friction between this wheel's tyre and the ground.
+ *
+ * Should be about 0.8 for realistic cars, but can increased for better
+ * handling. Set large (10000.0) for kart racers.
+ *
+ * @param frictionSlip the desired coefficient of friction (default=10.5)
*/
public void setFrictionSlip(float frictionSlip) {
this.frictionSlip = frictionSlip;
applyInfo();
}
+ /**
+ * Read this wheel's roll influence.
+ *
+ * @return the roll-influence factor
+ */
public float getRollInfluence() {
return rollInfluence;
}
/**
- * reduces the rolling torque applied from the wheels that cause the vehicle to roll over.
- * This is a bit of a hack, but it's quite effective. 0.0 = no roll, 1.0 = physical behaviour.
- * If m_frictionSlip is too high, you'll need to reduce this to stop the vehicle rolling over.
- * You should also try lowering the vehicle's centre of mass
- * @param rollInfluence the rollInfluence to set
+ * Alter this wheel's roll influence.
+ *
+ * The roll-influence factor reduces (or magnifies) the torque contributed
+ * by this wheel that tends to cause the vehicle to roll over. This is a bit
+ * of a hack, but it's quite effective.
+ *
+ * If the friction between the tyres and the ground is too high, you may
+ * reduce this factor to prevent the vehicle from rolling over. You should
+ * also try lowering the vehicle's centre of mass.
+ *
+ * @param rollInfluence the desired roll-influence factor (0→no roll
+ * torque, 1→realistic behaviour, default=1)
*/
public void setRollInfluence(float rollInfluence) {
this.rollInfluence = rollInfluence;
applyInfo();
}
+ /**
+ * Read the travel distance for this wheel's suspension.
+ *
+ * @return the maximum travel distance (in centimeters)
+ */
public float getMaxSuspensionTravelCm() {
return maxSuspensionTravelCm;
}
/**
- * the maximum distance the suspension can be compressed (centimetres)
- * @param maxSuspensionTravelCm
+ * Alter the travel distance for this wheel's suspension.
+ *
+ * @param maxSuspensionTravelCm the desired maximum travel distance (in
+ * centimetres, default=500)
*/
public void setMaxSuspensionTravelCm(float maxSuspensionTravelCm) {
this.maxSuspensionTravelCm = maxSuspensionTravelCm;
applyInfo();
}
+ /**
+ * Read the maximum force exerted by this wheel's suspension.
+ *
+ * @return the maximum force
+ */
public float getMaxSuspensionForce() {
return maxSuspensionForce;
}
/**
- * The maximum suspension force, raise this above the default 6000 if your suspension cannot
- * handle the weight of your vehcile.
- * @param maxSuspensionTravelCm
+ * Alter the maximum force exerted by this wheel's suspension.
+ *
+ * Increase this if your suspension cannot handle the weight of your
+ * vehicle.
+ *
+ * @param maxSuspensionForce the desired maximum force (default=6000)
*/
public void setMaxSuspensionForce(float maxSuspensionForce) {
this.maxSuspensionForce = maxSuspensionForce;
@@ -269,19 +476,40 @@ public class VehicleWheel implements Savable {
boolean frontWheel,
float suspensionRestLength);
+ /**
+ * Read the radius of this wheel.
+ *
+ * @return the radius (in physics-space units, ≥0)
+ */
public float getRadius() {
return radius;
}
+ /**
+ * Alter the radius of this wheel.
+ *
+ * @param radius the desired radius (in physics-space units, ≥0,
+ * default=0.5)
+ */
public void setRadius(float radius) {
this.radius = radius;
applyInfo();
}
+ /**
+ * Read the rest length of this wheel.
+ *
+ * @return the length
+ */
public float getRestLength() {
return restLength;
}
+ /**
+ * Alter the rest length of the suspension of this wheel.
+ *
+ * @param restLength the desired length (default=1)
+ */
public void setRestLength(float restLength) {
this.restLength = restLength;
applyInfo();
@@ -303,7 +531,10 @@ public class VehicleWheel implements Savable {
}
/**
- * returns the location where the wheel collides with the ground (world space)
+ * Copy the location where the wheel touches the ground.
+ *
+ * @param vec storage for the result (not null, modified)
+ * @return a new location vector (in physics-space coordinates, not null)
*/
public Vector3f getCollisionLocation(Vector3f vec) {
getCollisionLocation(wheelId, wheelIndex, vec);
@@ -313,7 +544,9 @@ public class VehicleWheel implements Savable {
private native void getCollisionLocation(long wheelId, int wheelIndex, Vector3f vec);
/**
- * returns the location where the wheel collides with the ground (world space)
+ * Copy the location where the wheel collides with the ground.
+ *
+ * @return a new location vector (in physics-space coordinates)
*/
public Vector3f getCollisionLocation() {
Vector3f vec = new Vector3f();
@@ -322,7 +555,10 @@ public class VehicleWheel implements Savable {
}
/**
- * returns the normal where the wheel collides with the ground (world space)
+ * Copy the normal where the wheel touches the ground.
+ *
+ * @param vec storage for the result (not null, modified)
+ * @return a unit vector (in physics-space coordinates, not null)
*/
public Vector3f getCollisionNormal(Vector3f vec) {
getCollisionNormal(wheelId, wheelIndex, vec);
@@ -332,7 +568,9 @@ public class VehicleWheel implements Savable {
private native void getCollisionNormal(long wheelId, int wheelIndex, Vector3f vec);
/**
- * returns the normal where the wheel collides with the ground (world space)
+ * Copy the normal where the wheel touches the ground.
+ *
+ * @return a new unit vector (in physics-space coordinates, not null)
*/
public Vector3f getCollisionNormal() {
Vector3f vec = new Vector3f();
@@ -341,8 +579,11 @@ public class VehicleWheel implements Savable {
}
/**
- * returns how much the wheel skids on the ground (for skid sounds/smoke etc.)
+ * This method is invoked from native code.
+ *
+ * @param x local X coordinate of new vertex
+ * @param y local Y coordinate of new vertex
+ * @param z local Z coordinate of new vertex
+ * @param part ignored
+ * @param index ignored
+ */
public void addVector(float x, float y, float z, int part, int index) {
list.add(new Vector3f(x, y, z));
}
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/util/DebugShapeFactory.java b/jme3-bullet/src/main/java/com/jme3/bullet/util/DebugShapeFactory.java
index c731035ca..d56440911 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/util/DebugShapeFactory.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/util/DebugShapeFactory.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -45,6 +45,7 @@ import java.util.Iterator;
import java.util.List;
/**
+ * A utility class to generate debug spatials from Bullet collision shapes.
*
* @author CJ Hare, normenhansen
*/
@@ -56,10 +57,13 @@ public class DebugShapeFactory {
// private static final Vector3f aabbMin = new Vector3f(-1e30f, -1e30f, -1e30f);
/**
- * Creates a debug shape from the given collision shape. This is mostly used internally.
+ * This is mostly used internally. To attach a debug shape to a physics
+ * object, call
+ * Note that using this constructor will cause the joints in the list
+ * to have their bind pose recomputed based on their local transforms.
+ *
+ * @param jointList The list of joints to manage by this Armature
+ */
+ public Armature(Joint[] jointList) {
+ this.jointList = jointList;
+
+ List
+ * The model transform of this bone is computed by combining the parent's
+ * model transform with this bones' local transform.
+ */
+ public final void updateModelTransforms() {
+ jointModelTransform.updateModelTransform(localTransform, parent);
+ updateAttachNode();
+ }
+
+ /**
+ * Update the local transform of the attachments node.
+ */
+ private void updateAttachNode() {
+ if (attachedNode == null) {
+ return;
+ }
+ Node attachParent = attachedNode.getParent();
+ if (attachParent == null || targetGeometry == null
+ || targetGeometry.getParent() == attachParent
+ && targetGeometry.getLocalTransform().isIdentity()) {
+ /*
+ * The animated meshes are in the same coordinate system as the
+ * attachments node: no further transforms are needed.
+ */
+ attachedNode.setLocalTransform(getModelTransform());
+
+ } else {
+ Spatial loopSpatial = targetGeometry;
+ Transform combined = getModelTransform().clone();
+ /*
+ * Climb the scene graph applying local transforms until the
+ * attachments node's parent is reached.
+ */
+ while (loopSpatial != attachParent && loopSpatial != null) {
+ Transform localTransform = loopSpatial.getLocalTransform();
+ combined.combineWithParent(localTransform);
+ loopSpatial = loopSpatial.getParent();
+ }
+ attachedNode.setLocalTransform(combined);
+ }
+ }
+
+ /**
+ * Stores the skinning transform in the specified Matrix4f.
+ * The skinning transform applies the animation of the bone to a vertex.
+ *
+ * This assumes that the world transforms for the entire bone hierarchy
+ * have already been computed, otherwise this method will return undefined
+ * results.
+ *
+ * @param outTransform
+ */
+ void getOffsetTransform(Matrix4f outTransform) {
+ jointModelTransform.getOffsetTransform(outTransform, inverseModelBindMatrix);
+ }
+
+ /**
+ * Sets the current localTransform as the Bind transform.
+ */
+ protected void saveBindPose() {
+ //Note that the whole Armature must be updated before calling this method.
+ getModelTransform().toTransformMatrix(inverseModelBindMatrix);
+ inverseModelBindMatrix.invertLocal();
+ }
+
+ /**
+ * Sets the current local transforms as the initial transform.
+ */
+ protected void saveInitialPose() {
+ initialTransform.set(localTransform);
+ }
+
+ /**
+ * Sets the local transform with the bind transforms
+ */
+ protected void applyBindPose() {
+ jointModelTransform.applyBindPose(localTransform, inverseModelBindMatrix, parent);
+ updateModelTransforms();
+
+ for (Joint child : children.getArray()) {
+ child.applyBindPose();
+ }
+ }
+
+ /**
+ * Sets the local transform with the initial transform
+ */
+ protected void applyInitialPose() {
+ setLocalTransform(initialTransform);
+ updateModelTransforms();
+
+ for (Joint child : children.getArray()) {
+ child.applyInitialPose();
+ }
+ }
+
+ protected JointModelTransform getJointModelTransform() {
+ return jointModelTransform;
+ }
+
+ protected void setJointModelTransform(JointModelTransform jointModelTransform) {
+ this.jointModelTransform = jointModelTransform;
+ }
+
+ public Vector3f getLocalTranslation() {
+ return localTransform.getTranslation();
+ }
+
+ public Quaternion getLocalRotation() {
+ return localTransform.getRotation();
+ }
+
+ public Vector3f getLocalScale() {
+ return localTransform.getScale();
+ }
+
+ public void setLocalTranslation(Vector3f translation) {
+ localTransform.setTranslation(translation);
+ }
+
+ public void setLocalRotation(Quaternion rotation) {
+ localTransform.setRotation(rotation);
+ }
+
+ public void setLocalScale(Vector3f scale) {
+ localTransform.setScale(scale);
+ }
+
+ public void addChild(Joint child) {
+ children.add(child);
+ child.parent = this;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public void setLocalTransform(Transform localTransform) {
+ this.localTransform.set(localTransform);
+ }
+
+ public void setInverseModelBindMatrix(Matrix4f inverseModelBindMatrix) {
+ this.inverseModelBindMatrix = inverseModelBindMatrix;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public Joint getParent() {
+ return parent;
+ }
+
+ public List
+ * It can perform software skinning or Hardware skinning
+ *
+ * @author Rémy Bouquet Based on SkeletonControl by Kirill Vainer
+ */
+public class SkinningControl extends AbstractControl implements Cloneable, JmeCloneable {
+
+ private static final Logger logger = Logger.getLogger(SkinningControl.class.getName());
+
+ /**
+ * The armature of the model.
+ */
+ private Armature armature;
+
+ /**
+ * List of geometries affected by this control.
+ */
+ private SafeArrayList
+ * For example: Would work for any of the following method signatures:
+ *
- * This resets the time to zero, and optionally blends the animation
- * over
- * See {@link #setAnim(java.lang.String, float)}.
- * The blendTime argument by default is 150 milliseconds.
- *
- * @param name The name of the animation to play
- */
- public void setAnim(String name){
- setAnim(name, DEFAULT_BLEND_TIME);
- }
-
- /**
- * Add all the bones of the model's skeleton to be
- * influenced by this animation channel.
- */
- public void addAllBones() {
- affectedBones = null;
- }
-
- /**
- * Add a single bone to be influenced by this animation channel.
- */
- public void addBone(String name) {
- addBone(control.getSkeleton().getBone(name));
- }
-
- /**
- * Add a single bone to be influenced by this animation channel.
- */
- public void addBone(Bone bone) {
- int boneIndex = control.getSkeleton().getBoneIndex(bone);
- if(affectedBones == null) {
- affectedBones = new BitSet(control.getSkeleton().getBoneCount());
- }
- affectedBones.set(boneIndex);
- }
-
- /**
- * Add bones to be influenced by this animation channel starting from the
- * given bone name and going toward the root bone.
- */
- public void addToRootBone(String name) {
- addToRootBone(control.getSkeleton().getBone(name));
- }
-
- /**
- * Add bones to be influenced by this animation channel starting from the
- * given bone and going toward the root bone.
- */
- public void addToRootBone(Bone bone) {
- addBone(bone);
- while (bone.getParent() != null) {
- bone = bone.getParent();
- addBone(bone);
- }
- }
-
- /**
- * Add bones to be influenced by this animation channel, starting
- * from the given named bone and going toward its children.
- */
- public void addFromRootBone(String name) {
- addFromRootBone(control.getSkeleton().getBone(name));
- }
-
- /**
- * Add bones to be influenced by this animation channel, starting
- * from the given bone and going toward its children.
- */
- public void addFromRootBone(Bone bone) {
- addBone(bone);
- if (bone.getChildren() == null)
- return;
- for (Bone childBone : bone.getChildren()) {
- addBone(childBone);
- addFromRootBone(childBone);
- }
- }
-
- BitSet getAffectedBones(){
- return affectedBones;
- }
-
- public void reset(boolean rewind){
- if(rewind){
- setTime(0);
- if(control.getSkeleton()!=null){
- control.getSkeleton().resetAndUpdate();
- }else{
- TempVars vars = TempVars.get();
- update(0, vars);
- vars.release();
- }
- }
- animation = null;
- notified = false;
- }
-
- void update(float tpf, TempVars vars) {
- if (animation == null)
- return;
-
- if (blendFrom != null && blendAmount != 1.0f){
- // The blendFrom anim is set, the actual animation
- // playing will be set
-// blendFrom.setTime(timeBlendFrom, 1f, control, this, vars);
- blendFrom.setTime(timeBlendFrom, 1f - blendAmount, control, this, vars);
-
- timeBlendFrom += tpf * speedBlendFrom;
- timeBlendFrom = AnimationUtils.clampWrapTime(timeBlendFrom,
- blendFrom.getLength(),
- loopModeBlendFrom);
- if (timeBlendFrom < 0){
- timeBlendFrom = -timeBlendFrom;
- speedBlendFrom = -speedBlendFrom;
- }
-
- blendAmount += tpf * blendRate;
- if (blendAmount > 1f){
- blendAmount = 1f;
- blendFrom = null;
- }
- }
-
- animation.setTime(time, blendAmount, control, this, vars);
- time += tpf * speed;
- if (animation.getLength() > 0){
- if (!notified && (time >= animation.getLength() || time < 0)) {
- if (loopMode == LoopMode.DontLoop) {
- // Note that this flag has to be set before calling the notify
- // since the notify may start a new animation and then unset
- // the flag.
- notified = true;
- }
- control.notifyAnimCycleDone(this, animation.getName());
- }
- }
- time = AnimationUtils.clampWrapTime(time, animation.getLength(), loopMode);
- if (time < 0){
- // Negative time indicates that speed should be inverted
- // (for cycle loop mode only)
- time = -time;
- speed = -speed;
- }
- }
-}
+/*
+ * Copyright (c) 2009-2012 jMonkeyEngine
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.jme3.animation;
+
+import com.jme3.math.FastMath;
+import com.jme3.util.TempVars;
+
+import java.util.BitSet;
+
+/**
+ *
+ * This resets the time to zero, and optionally blends the animation
+ * over
+ * See {@link #setAnim(java.lang.String, float)}.
+ * The blendTime argument by default is 150 milliseconds.
+ *
+ * @param name The name of the animation to play
+ */
+ public void setAnim(String name){
+ setAnim(name, DEFAULT_BLEND_TIME);
+ }
+
+ /**
+ * Add all the bones of the model's skeleton to be
+ * influenced by this animation channel.
+ */
+ public void addAllBones() {
+ affectedBones = null;
+ }
+
+ /**
+ * Add a single bone to be influenced by this animation channel.
+ */
+ public void addBone(String name) {
+ addBone(control.getSkeleton().getBone(name));
+ }
+
+ /**
+ * Add a single bone to be influenced by this animation channel.
+ */
+ public void addBone(Bone bone) {
+ int boneIndex = control.getSkeleton().getBoneIndex(bone);
+ if(affectedBones == null) {
+ affectedBones = new BitSet(control.getSkeleton().getBoneCount());
+ }
+ affectedBones.set(boneIndex);
+ }
+
+ /**
+ * Add bones to be influenced by this animation channel starting from the
+ * given bone name and going toward the root bone.
+ */
+ public void addToRootBone(String name) {
+ addToRootBone(control.getSkeleton().getBone(name));
+ }
+
+ /**
+ * Add bones to be influenced by this animation channel starting from the
+ * given bone and going toward the root bone.
+ */
+ public void addToRootBone(Bone bone) {
+ addBone(bone);
+ while (bone.getParent() != null) {
+ bone = bone.getParent();
+ addBone(bone);
+ }
+ }
+
+ /**
+ * Add bones to be influenced by this animation channel, starting
+ * from the given named bone and going toward its children.
+ */
+ public void addFromRootBone(String name) {
+ addFromRootBone(control.getSkeleton().getBone(name));
+ }
+
+ /**
+ * Add bones to be influenced by this animation channel, starting
+ * from the given bone and going toward its children.
+ */
+ public void addFromRootBone(Bone bone) {
+ addBone(bone);
+ if (bone.getChildren() == null)
+ return;
+ for (Bone childBone : bone.getChildren()) {
+ addBone(childBone);
+ addFromRootBone(childBone);
+ }
+ }
+
+ BitSet getAffectedBones(){
+ return affectedBones;
+ }
+
+ public void reset(boolean rewind){
+ if(rewind){
+ setTime(0);
+ if(control.getSkeleton()!=null){
+ control.getSkeleton().resetAndUpdate();
+ }else{
+ TempVars vars = TempVars.get();
+ update(0, vars);
+ vars.release();
+ }
+ }
+ animation = null;
+ notified = false;
+ }
+
+ void update(float tpf, TempVars vars) {
+ if (animation == null)
+ return;
+
+ if (blendFrom != null && blendAmount != 1.0f){
+ // The blendFrom anim is set, the actual animation
+ // playing will be set
+// blendFrom.setTime(timeBlendFrom, 1f, control, this, vars);
+ blendFrom.setTime(timeBlendFrom, 1f - blendAmount, control, this, vars);
+
+ timeBlendFrom += tpf * speedBlendFrom;
+ timeBlendFrom = AnimationUtils.clampWrapTime(timeBlendFrom,
+ blendFrom.getLength(),
+ loopModeBlendFrom);
+ if (timeBlendFrom < 0){
+ timeBlendFrom = -timeBlendFrom;
+ speedBlendFrom = -speedBlendFrom;
+ }
+
+ blendAmount += tpf * blendRate;
+ if (blendAmount > 1f){
+ blendAmount = 1f;
+ blendFrom = null;
+ }
+ }
+
+ animation.setTime(time, blendAmount, control, this, vars);
+ time += tpf * speed;
+ if (animation.getLength() > 0){
+ if (!notified && (time >= animation.getLength() || time < 0)) {
+ if (loopMode == LoopMode.DontLoop) {
+ // Note that this flag has to be set before calling the notify
+ // since the notify may start a new animation and then unset
+ // the flag.
+ notified = true;
+ }
+ control.notifyAnimCycleDone(this, animation.getName());
+ }
+ }
+ time = AnimationUtils.clampWrapTime(time, animation.getLength(), loopMode);
+ if (time < 0){
+ // Negative time indicates that speed should be inverted
+ // (for cycle loop mode only)
+ time = -time;
+ speed = -speed;
+ }
+ }
+}
diff --git a/jme3-core/src/main/java/com/jme3/animation/AnimControl.java b/jme3-core/src/main/java/com/jme3/animation/AnimControl.java
index 36dbb6be5..7386e1084 100644
--- a/jme3-core/src/main/java/com/jme3/animation/AnimControl.java
+++ b/jme3-core/src/main/java/com/jme3/animation/AnimControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -34,19 +34,16 @@ package com.jme3.animation;
import com.jme3.export.*;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
-import com.jme3.scene.Mesh;
import com.jme3.scene.Spatial;
import com.jme3.scene.control.AbstractControl;
-import com.jme3.scene.control.Control;
+import com.jme3.util.TempVars;
import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
-import com.jme3.util.TempVars;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
-import java.util.Map.Entry;
/**
*
- * Objects with "mesh" type collision shape will not collide with each other.
+ * This type of collision shape is mesh-accurate and meant for immovable
+ * "world objects". Examples include terrain, houses or whole shooter
+ * levels.
+ *
- * Objects with "mesh" type collision shape will not collide with each other.
- * Creates a HeightfieldCollisionShape if the supplied spatial is a TerrainQuad.
- * @return A MeshCollisionShape or a CompoundCollisionShape with MeshCollisionShapes as children if the supplied spatial is a Node. A HeightieldCollisionShape if a TerrainQuad was supplied.
+ * Create a mesh shape for the given Spatial.
+ *
- * If you want to have mesh-accurate dynamic shapes (CPU intense!!!) use GImpact shapes, its probably best to do so with a low-poly version of your model.
- * @return A HullCollisionShape or a CompoundCollisionShape with HullCollisionShapes as children if the supplied spatial is a Node.
+ * Create a hull shape for the given Spatial.
+ *
- * Objects with "mesh" type collision shape will not collide with each other.
+ * This type of collision shape is mesh-accurate and meant for immovable
+ * "world objects". Examples include terrain, houses or whole shooter
+ * levels.
+ *
+ * Create a hull collision shape for the specified geometry.
+ *
+ * @param geom the geometry on which to base the shape (not null)
+ * @param parent
*/
private static HullCollisionShape createSingleDynamicMeshShape(Geometry geom, Spatial parent) {
Mesh mesh = geom.getMesh();
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/PhysicsSpace.java b/jme3-bullet/src/main/java/com/jme3/bullet/PhysicsSpace.java
index 74c44a0b9..ea5f74518 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/PhysicsSpace.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/PhysicsSpace.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,7 +32,6 @@
package com.jme3.bullet;
import com.jme3.app.AppTask;
-import com.jme3.asset.AssetManager;
import com.jme3.bullet.collision.*;
import com.jme3.bullet.collision.shapes.CollisionShape;
import com.jme3.bullet.control.PhysicsControl;
@@ -46,6 +45,7 @@ import com.jme3.math.Transform;
import com.jme3.math.Vector3f;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
+import com.jme3.util.SafeArrayList;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
@@ -55,6 +55,7 @@ import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Comparator;
+import java.util.Deque;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
@@ -63,17 +64,36 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- *
For
- * parallel physics, this can also be called from the OpenGL thread to
- * receive the PhysicsSpace
+ * Access the PhysicsSpace running on this thread. For parallel
+ * physics, this can be invoked from the OpenGL thread.
*
* @return the PhysicsSpace running on this thread
*/
@@ -125,24 +188,47 @@ public class PhysicsSpace {
/**
* Used internally
*
- * @param space
+ * @param space which physics space to simulate on this thread
*/
public static void setLocalThreadPhysicsSpace(PhysicsSpace space) {
physicsSpaceTL.set(space);
}
+ /**
+ * Instantiate a PhysicsSpace. Must be invoked on the designated physics
+ * thread.
+ */
public PhysicsSpace() {
this(new Vector3f(-10000f, -10000f, -10000f), new Vector3f(10000f, 10000f, 10000f), BroadphaseType.DBVT);
}
+ /**
+ * Instantiate a PhysicsSpace. Must be invoked on the designated physics
+ * thread.
+ */
public PhysicsSpace(BroadphaseType broadphaseType) {
this(new Vector3f(-10000f, -10000f, -10000f), new Vector3f(10000f, 10000f, 10000f), broadphaseType);
}
+ /**
+ * Instantiate a PhysicsSpace. Must be invoked on the designated physics
+ * thread.
+ */
public PhysicsSpace(Vector3f worldMin, Vector3f worldMax) {
this(worldMin, worldMax, BroadphaseType.AXIS_SWEEP_3);
}
+ /**
+ * Instantiate a PhysicsSpace. Must be invoked on the designated physics
+ * thread.
+ *
+ * @param worldMin the desired minimum coordinates values (not null,
+ * unaffected, default=-10k,-10k,-10k)
+ * @param worldMax the desired minimum coordinates values (not null,
+ * unaffected, default=10k,10k,10k)
+ * @param broadphaseType which broadphase collision-detection algorithm to
+ * use (not null)
+ */
public PhysicsSpace(Vector3f worldMin, Vector3f worldMax, BroadphaseType broadphaseType) {
this.worldMin.set(worldMin);
this.worldMax.set(worldMax);
@@ -151,7 +237,7 @@ public class PhysicsSpace {
}
/**
- * Has to be called from the (designated) physics thread
+ * Must be invoked on the designated physics thread.
*/
public void create() {
physicsSpaceId = createPhysicsSpace(worldMin.x, worldMin.y, worldMin.z, worldMax.x, worldMax.y, worldMax.z, broadphaseType.ordinal(), false);
@@ -192,26 +278,37 @@ public class PhysicsSpace {
private native long createPhysicsSpace(float minX, float minY, float minZ, float maxX, float maxY, float maxZ, int broadphaseType, boolean threading);
+ /**
+ * Callback invoked just before the physics is stepped.
+ *
+ * Simulate for the specified time interval, using no more than the
+ * specified number of steps.
*
- * @param time the current time value
- * @param maxSteps
+ * @param time the time interval (in seconds, ≥0)
+ * @param maxSteps the maximum number of steps (≥1)
*/
public void update(float time, int maxSteps) {
// if (getDynamicsWorld() == null) {
@@ -378,6 +483,9 @@ public class PhysicsSpace {
private native void stepSimulation(long space, float time, int maxSteps, float accuracy);
+ /**
+ * Distribute each collision event to all listeners.
+ */
public void distributeEvents() {
//add collision callbacks
int clistsize = collisionListeners.size();
@@ -391,6 +499,13 @@ public class PhysicsSpace {
}
}
+ /**
+ * Enqueue a callable on the currently executing thread.
+ *
+ * @param
There can be only one listener
- * per collision group.
+ * Register the specified collision-group listener with the specified
+ * collision group of this space.
+ *
You have to use different Transforms for
- * start and end (at least distance > 0.4f). SweepTest will not see a
- * collision if it starts INSIDE an object and is moving AWAY from its
- * center.
+ * Perform a sweep-collision test and return the results as a new list.
+ *
You have to use different Transforms for
- * start and end (at least distance > allowedCcdPenetration). SweepTest will not see a
- * collision if it starts INSIDE an object and is moving AWAY from its
- * center.
+ * Perform a sweep-collision test and store the results in an existing list.
+ *
+ * Alter the accuracy (time step) of the physics simulation.
+ *
- * The groups are integer bit masks and some pre-made variables are available in CollisionObject.
- * All physics objects are by default in COLLISION_GROUP_01.
- * Two object will collide when one of the partys has the
- * collisionGroup of the other in its collideWithGroups set.
- * @param collisionGroup the collisionGroup to set
+ * Alter the collision group for this physics object.
+ *
- * Two object will collide when one of the partys has the
- * collisionGroup of the other in its collideWithGroups set.
- * @param collisionGroup
+ * Add collision groups to the set with which this object can collide.
+ *
+ * Two objects can collide only if one of them has the collisionGroup of the
+ * other in its collideWithGroups set.
+ *
+ * @param collisionGroup groups to add (bit mask)
*/
public void addCollideWithGroup(int collisionGroup) {
this.collisionGroupsMask = this.collisionGroupsMask | collisionGroup;
@@ -121,8 +203,9 @@ public abstract class PhysicsCollisionObject implements Savable {
}
/**
- * Remove a group from the list this object collides with.
- * @param collisionGroup
+ * Remove collision groups from the set with which this object can collide.
+ *
+ * @param collisionGroup groups to remove, ORed together (bit mask)
*/
public void removeCollideWithGroup(int collisionGroup) {
this.collisionGroupsMask = this.collisionGroupsMask & ~collisionGroup;
@@ -132,8 +215,9 @@ public abstract class PhysicsCollisionObject implements Savable {
}
/**
- * Directly set the bitmask for collision groups that this object collides with.
- * @param collisionGroups
+ * Directly alter the collision groups with which this object can collide.
+ *
+ * @param collisionGroups desired groups, ORed together (bit mask)
*/
public void setCollideWithGroups(int collisionGroups) {
this.collisionGroupsMask = collisionGroups;
@@ -143,13 +227,18 @@ public abstract class PhysicsCollisionObject implements Savable {
}
/**
- * Gets the bitmask of collision groups that this object collides with.
- * @return Collision groups mask
+ * Read the set of collision groups with which this object can collide.
+ *
+ * @return bit mask
*/
public int getCollideWithGroups() {
return collisionGroupsMask;
}
+ /**
+ * Initialize the user pointer and collision-group information of this
+ * object.
+ */
protected void initUserPointer() {
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "initUserPointer() objectId = {0}", Long.toHexString(objectId));
initUserPointer(objectId, collisionGroup, collisionGroupsMask);
@@ -157,27 +246,62 @@ public abstract class PhysicsCollisionObject implements Savable {
native void initUserPointer(long objectId, int group, int groups);
/**
- * @return the userObject
+ * Access the user object associated with this collision object.
+ *
+ * @return the pre-existing instance, or null if none
*/
public Object getUserObject() {
return userObject;
}
/**
- * @param userObject the userObject to set
+ * Test whether this object responds to contact with other objects.
+ *
+ * @return true if responsive, otherwise false
+ */
+ public boolean isContactResponse() {
+ int flags = getCollisionFlags(objectId);
+ boolean result = (flags & CollisionFlag.NO_CONTACT_RESPONSE) == 0x0;
+ return result;
+ }
+
+ /**
+ * Associate a user object (such as a Spatial) with this collision object.
+ *
+ * @param userObject the object to associate with this collision object
+ * (alias created, may be null)
*/
public void setUserObject(Object userObject) {
this.userObject = userObject;
}
- public long getObjectId(){
+ /**
+ * Read the id of the btCollisionObject.
+ *
+ * @return the unique identifier (not zero)
+ */
+ public long getObjectId(){
return objectId;
}
+ /**
+ * Attach the identified btCollisionShape to the identified
+ * btCollisionObject. Native method.
+ *
+ * @param objectId the unique identifier of the btCollisionObject (not zero)
+ * @param collisionShapeId the unique identifier of the btCollisionShape
+ * (not zero)
+ */
protected native void attachCollisionShape(long objectId, long collisionShapeId);
native void setCollisionGroup(long objectId, int collisionGroup);
native void setCollideWithGroups(long objectId, int collisionGroups);
+ /**
+ * Serialize this object, for example when saving to a J3O file.
+ *
+ * @param e exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter e) throws IOException {
OutputCapsule capsule = e.getCapsule(this);
@@ -186,6 +310,12 @@ public abstract class PhysicsCollisionObject implements Savable {
capsule.write(collisionShape, "collisionShape", null);
}
+ /**
+ * De-serialize this object, for example when loading from a J3O file.
+ *
+ * @param e importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter e) throws IOException {
InputCapsule capsule = e.getCapsule(this);
@@ -195,6 +325,30 @@ public abstract class PhysicsCollisionObject implements Savable {
collisionShape = shape;
}
+ /**
+ * Read the collision flags of this object. Subclasses are responsible for
+ * cloning/reading/writing these flags.
+ *
+ * @param objectId the ID of the btCollisionObject (not zero)
+ * @return the collision flags (bit mask)
+ */
+ native protected int getCollisionFlags(long objectId);
+
+ /**
+ * Alter the collision flags of this object. Subclasses are responsible for
+ * cloning/reading/writing these flags.
+ *
+ * @param objectId the ID of the btCollisionObject (not zero)
+ * @param desiredFlags the desired collision flags (bit mask)
+ */
+ native protected void setCollisionFlags(long objectId, int desiredFlags);
+
+ /**
+ * Finalize this collision object just before it is destroyed. Should be
+ * invoked only by a subclass or by the garbage collector.
+ *
+ * @throws Throwable ignored by the garbage collector
+ */
@Override
protected void finalize() throws Throwable {
super.finalize();
@@ -202,5 +356,10 @@ public abstract class PhysicsCollisionObject implements Savable {
finalizeNative(objectId);
}
+ /**
+ * Finalize the identified btCollisionObject. Native method.
+ *
+ * @param objectId the unique identifier of the btCollisionObject (not zero)
+ */
protected native void finalizeNative(long objectId);
}
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsRayTestResult.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsRayTestResult.java
index bbc231fa7..02bf0162e 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsRayTestResult.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsRayTestResult.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -34,47 +34,67 @@ package com.jme3.bullet.collision;
import com.jme3.math.Vector3f;
/**
- * Contains the results of a PhysicsSpace rayTest
- * bulletAppState.getPhysicsSpace().rayTest(new Vector3f(0,1000,0),new Vector3f(0,-1000,0));
- javap -s java.util.List
+ * Represent the results of a Bullet ray test.
+ *
* @author Empire-Phoenix,normenhansen
*/
public class PhysicsRayTestResult {
+ /**
+ * collision object that was hit
+ */
private PhysicsCollisionObject collisionObject;
+ /**
+ * normal vector at the point of contact
+ */
private Vector3f hitNormalLocal;
+ /**
+ * fraction of the ray's total length (from=0, to=1, ≥0, ≤1)
+ */
private float hitFraction;
+ /**
+ * true→need to transform normal into world space
+ */
private boolean normalInWorldSpace = true;
/**
- * allocated by native code only
+ * A private constructor to inhibit instantiation of this class by Java.
+ * These results are instantiated exclusively by native code.
*/
private PhysicsRayTestResult() {
}
/**
- * @return the collisionObject
+ * Access the collision object that was hit.
+ *
+ * @return the pre-existing instance
*/
public PhysicsCollisionObject getCollisionObject() {
return collisionObject;
}
/**
- * @return the hitNormalLocal
+ * Access the normal vector at the point of contact.
+ *
+ * @return a pre-existing unit vector (not null)
*/
public Vector3f getHitNormalLocal() {
return hitNormalLocal;
}
/**
- * @return the hitFraction
+ * Read the fraction of the ray's total length.
+ *
+ * @return fraction (from=0, to=1, ≥0, ≤1)
*/
public float getHitFraction() {
return hitFraction;
}
/**
- * @return the normalInWorldSpace
+ * Test whether the normal is in world space.
+ *
+ * @return true if in world space, otherwise false
*/
public boolean isNormalInWorldSpace() {
return normalInWorldSpace;
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsSweepTestResult.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsSweepTestResult.java
index 8e61b66a2..9becbb1c7 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsSweepTestResult.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/PhysicsSweepTestResult.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -34,16 +34,33 @@ package com.jme3.bullet.collision;
import com.jme3.math.Vector3f;
/**
- * Contains the results of a PhysicsSpace rayTest
+ * Represent the results of a Bullet sweep test.
+ *
* @author normenhansen
*/
public class PhysicsSweepTestResult {
+ /**
+ * collision object that was hit
+ */
private PhysicsCollisionObject collisionObject;
+ /**
+ * normal vector at the point of contact
+ */
private Vector3f hitNormalLocal;
+ /**
+ * fraction of the way between the transforms (from=0, to=1, ≥0, ≤1)
+ */
private float hitFraction;
+ /**
+ * true→need to transform normal into world space
+ */
private boolean normalInWorldSpace;
+ /**
+ * A private constructor to inhibit instantiation of this class by Java.
+ * These results are instantiated exclusively by native code.
+ */
public PhysicsSweepTestResult() {
}
@@ -55,33 +72,50 @@ public class PhysicsSweepTestResult {
}
/**
- * @return the collisionObject
+ * Access the collision object that was hit.
+ *
+ * @return the pre-existing instance
*/
public PhysicsCollisionObject getCollisionObject() {
return collisionObject;
}
/**
- * @return the hitNormalLocal
+ * Access the normal vector at the point of contact.
+ *
+ * @return the pre-existing vector (not null)
*/
public Vector3f getHitNormalLocal() {
return hitNormalLocal;
}
/**
- * @return the hitFraction
+ * Read the fraction of fraction of the way between the transforms (from=0,
+ * to=1, ≥0, ≤1)
+ *
+ * @return fraction (from=0, to=1, ≥0, ≤1)
*/
public float getHitFraction() {
return hitFraction;
}
/**
- * @return the normalInWorldSpace
+ * Test whether the normal is in world space.
+ *
+ * @return true if in world space, otherwise false
*/
public boolean isNormalInWorldSpace() {
return normalInWorldSpace;
}
+ /**
+ * Fill in the fields of this result.
+ *
+ * @param collisionObject
+ * @param hitNormalLocal
+ * @param hitFraction
+ * @param normalInWorldSpace
+ */
public void fill(PhysicsCollisionObject collisionObject, Vector3f hitNormalLocal, float hitFraction, boolean normalInWorldSpace) {
this.collisionObject = collisionObject;
this.hitNormalLocal = hitNormalLocal;
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/BoxCollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/BoxCollisionShape.java
index 000bb2dc7..bec41ff97 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/BoxCollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/BoxCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -41,35 +41,63 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * Basic box collision shape
+ * A rectangular-solid collision shape based on Bullet's btBoxShape.
+ *
* @author normenhansen
*/
public class BoxCollisionShape extends CollisionShape {
+ /**
+ * copy of half-extents of the box on each local axis (not null, no negative
+ * component)
+ */
private Vector3f halfExtents;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public BoxCollisionShape() {
}
/**
- * creates a collision box from the given halfExtents
- * @param halfExtents the halfExtents of the CollisionBox
+ * Instantiate a box shape with the specified half extents.
+ *
+ * @param halfExtents the desired unscaled half extents (not null, no
+ * negative component, alias created)
*/
public BoxCollisionShape(Vector3f halfExtents) {
this.halfExtents = halfExtents;
createShape();
}
+ /**
+ * Access the half extents of the box.
+ *
+ * @return the pre-existing instance (not null, no negative component)
+ */
public final Vector3f getHalfExtents() {
return halfExtents;
}
-
+
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
super.write(ex);
OutputCapsule capsule = ex.getCapsule(this);
capsule.write(halfExtents, "halfExtents", new Vector3f(1, 1, 1));
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
super.read(im);
InputCapsule capsule = im.getCapsule(this);
@@ -78,6 +106,9 @@ public class BoxCollisionShape extends CollisionShape {
createShape();
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
protected void createShape() {
objectId = createShape(halfExtents);
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Shape {0}", Long.toHexString(objectId));
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CapsuleCollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CapsuleCollisionShape.java
index 00ccdf74e..0a15b343e 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CapsuleCollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CapsuleCollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -41,20 +41,37 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * Basic capsule collision shape
+ * A capsule collision shape based on Bullet's btCapsuleShapeX, btCapsuleShape,
+ * or btCapsuleShapeZ. These shapes have no margin and cannot be scaled.
+ *
* @author normenhansen
*/
public class CapsuleCollisionShape extends CollisionShape{
- protected float radius,height;
- protected int axis;
+ /**
+ * copy of height of the cylindrical portion (≥0)
+ */
+ private float height;
+ /**
+ * copy of radius (≥0)
+ */
+ private float radius;
+ /**
+ * copy of main (height) axis (0→X, 1→Y, 2→Z)
+ */
+ private int axis;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public CapsuleCollisionShape() {
}
/**
- * creates a new CapsuleCollisionShape with the given radius and height
- * @param radius the radius of the capsule
- * @param height the height of the capsule
+ * Instantiate a Y-axis capsule shape with the specified radius and height.
+ *
+ * @param radius the desired radius (≥0)
+ * @param height the desired height (of the cylindrical portion) (≥0)
*/
public CapsuleCollisionShape(float radius, float height) {
this.radius=radius;
@@ -64,10 +81,11 @@ public class CapsuleCollisionShape extends CollisionShape{
}
/**
- * creates a capsule shape around the given axis (0=X,1=Y,2=Z)
- * @param radius
- * @param height
- * @param axis
+ * Instantiate a capsule shape around the specified main (height) axis.
+ *
+ * @param radius the desired radius (≥0)
+ * @param height the desired height (of the cylindrical portion) (≥0)
+ * @param axis which local axis: 0→X, 1→Y, 2→Z
*/
public CapsuleCollisionShape(float radius, float height, int axis) {
this.radius=radius;
@@ -76,20 +94,39 @@ public class CapsuleCollisionShape extends CollisionShape{
createShape();
}
+ /**
+ * Read the radius of the capsule.
+ *
+ * @return the radius (≥0)
+ */
public float getRadius() {
return radius;
}
+ /**
+ * Read the height (of the cylindrical portion) of the capsule.
+ *
+ * @return height (≥0)
+ */
public float getHeight() {
return height;
}
+ /**
+ * Determine the main (height) axis of the capsule.
+ *
+ * @return 0 for local X, 1 for local Y, or 2 for local Z
+ */
public int getAxis() {
return axis;
}
/**
- * WARNING - CompoundCollisionShape scaling has no effect.
+ * Alter the scaling factors of this shape. Scaling is disabled
+ * for capsule shapes.
+ *
+ * @param scale the desired scaling factor for each local axis (not null, no
+ * negative component, unaffected, default=1,1,1)
*/
@Override
public void setScale(Vector3f scale) {
@@ -98,6 +135,12 @@ public class CapsuleCollisionShape extends CollisionShape{
}
}
+ /**
+ * Serialize this shape, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
super.write(ex);
OutputCapsule capsule = ex.getCapsule(this);
@@ -106,6 +149,12 @@ public class CapsuleCollisionShape extends CollisionShape{
capsule.write(axis, "axis", 1);
}
+ /**
+ * De-serialize this shape, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
super.read(im);
InputCapsule capsule = im.getCapsule(this);
@@ -115,6 +164,9 @@ public class CapsuleCollisionShape extends CollisionShape{
createShape();
}
+ /**
+ * Instantiate the configured shape in Bullet.
+ */
protected void createShape(){
objectId = createShape(axis, radius, height);
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Shape {0}", Long.toHexString(objectId));
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CollisionShape.java b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CollisionShape.java
index c5b390e0e..ea6f11be9 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CollisionShape.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/collision/shapes/CollisionShape.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -38,15 +38,31 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * This Object holds information about a jbullet CollisionShape to be able to reuse
- * CollisionShapes (as suggested in bullet manuals)
- * TODO: add static methods to create shapes from nodes (like jbullet-jme constructor)
+ * The abstract base class for collision shapes based on Bullet's
+ * btCollisionShape.
+ *
+ *
+ *
* @author Brent Owens
*/
public class HeightfieldCollisionShape extends CollisionShape {
+ /**
+ * number of rows in the heightfield (>1)
+ */
protected int heightStickWidth;
+ /**
+ * number of columns in the heightfield (>1)
+ */
protected int heightStickLength;
+ /**
+ * array of heightfield samples
+ */
protected float[] heightfieldData;
protected float heightScale;
protected float minHeight;
protected float maxHeight;
+ /**
+ * index of the height axis (0→X, 1→Y, 2→Z)
+ */
protected int upAxis;
protected boolean flipQuadEdges;
+ /**
+ * buffer for passing height data to Bullet
+ * memoryOptimized
determines if optimized instead of
- * quantized BVH will be used.
- * Internally, memoryOptimized
BVH is slower to calculate (~4x)
- * but also smaller (~0.5x).
- * It is preferable to use the memory optimized version and then serialize
- * the resulting MeshCollisionshape as this will also save the
- * generated BVH.
- * An exception can be procedurally / generated collision shapes, where
- * the generation time is more of a concern
+ * Instantiate a collision shape based on the specified JME mesh.
+ * memoryOptimized
determines if optimized instead of quantized
+ * BVH will be used. Internally, memoryOptimized
BVH is slower
+ * to calculate (~4x) but also smaller (~0.5x). It is preferable to use the
+ * memory optimized version and then serialize the resulting
+ * MeshCollisionshape as this will also save the generated BVH. An exception
+ * can be procedurally / generated collision shapes, where the generation
+ * time is more of a concern
*
- * @param mesh the Mesh to use
- * @param memoryOptimized True to generate a memory optimized BVH,
- * false to generate quantized BVH.
+ * @param mesh the mesh on which to base the shape (not null)
+ * @param memoryOptimized true to generate a memory-optimized BVH, false to
+ * generate quantized BVH
*/
public MeshCollisionShape(final Mesh mesh, final boolean memoryOptimized) {
this.memoryOptimized = memoryOptimized;
@@ -103,16 +110,15 @@ public class MeshCollisionShape extends CollisionShape {
}
/**
- * Advanced constructor, usually you don’t want to use this, but the Mesh
- * based one. Passing false values can lead to a crash, use at own risk
- *
+ * An advanced constructor. Passing false values can lead to a crash.
+ * Usually you don’t want to use this. Use at own risk.
+ *
- * To create ragdolls, the conve twist constraint is very useful for limbs like the upper arm.
- * It is a special point to point constraint that adds cone and twist axis limits.
- * The x-axis serves as twist axis.
+ * A joint based on Bullet's btConeTwistConstraint.
+ *
+ * To create ragdolls, the cone twist constraint is very useful for limbs like
+ * the upper arm. It is a special point to point constraint that adds cone and
+ * twist axis limits. The x-axis serves as twist axis.
+ *
* @author normenhansen
*/
public class ConeJoint extends PhysicsJoint {
@@ -57,12 +60,25 @@ public class ConeJoint extends PhysicsJoint {
protected float twistSpan = 1e30f;
protected boolean angularOnly = false;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public ConeJoint() {
}
/**
- * @param pivotA local translation of the joint connection point in node A
- * @param pivotB local translation of the joint connection point in node B
+ * Instantiate a ConeJoint. To be effective, the joint must be added to a
+ * physics space.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
+ * @param pivotA the local offset of the connection point in node A (not
+ * null, alias created)
+ * @param pivotB the local offset of the connection point in node B (not
+ * null, alias created)
*/
public ConeJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB) {
super(nodeA, nodeB, pivotA, pivotB);
@@ -72,8 +88,21 @@ public class ConeJoint extends PhysicsJoint {
}
/**
+ * Instantiate a ConeJoint. To be effective, the joint must be added to a
+ * physics space.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
* @param pivotA local translation of the joint connection point in node A
+ * (not null, alias created)
* @param pivotB local translation of the joint connection point in node B
+ * (not null, alias created)
+ * @param rotA the local orientation of the connection to node A (not null,
+ * alias created)
+ * @param rotB the local orientation of the connection to node B (not null,
+ * alias created)
*/
public ConeJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB) {
super(nodeA, nodeB, pivotA, pivotB);
@@ -82,6 +111,13 @@ public class ConeJoint extends PhysicsJoint {
createJoint();
}
+ /**
+ * Alter the angular limits for this joint.
+ *
+ * @param swingSpan1 angle (in radians)
+ * @param swingSpan2 angle (in radians)
+ * @param twistSpan angle (in radians)
+ */
public void setLimit(float swingSpan1, float swingSpan2, float twistSpan) {
this.swingSpan1 = swingSpan1;
this.swingSpan2 = swingSpan2;
@@ -91,6 +127,11 @@ public class ConeJoint extends PhysicsJoint {
private native void setLimit(long objectId, float swingSpan1, float swingSpan2, float twistSpan);
+ /**
+ * Alter whether this joint is angular only.
+ *
+ * @param value the desired setting (default=false)
+ */
public void setAngularOnly(boolean value) {
angularOnly = value;
setAngularOnly(objectId, value);
@@ -98,6 +139,12 @@ public class ConeJoint extends PhysicsJoint {
private native void setAngularOnly(long objectId, boolean value);
+ /**
+ * Serialize this joint, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -111,6 +158,12 @@ public class ConeJoint extends PhysicsJoint {
capsule.write(twistSpan, "twistSpan", 1e30f);
}
+ /**
+ * De-serialize this joint, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
@@ -125,6 +178,9 @@ public class ConeJoint extends PhysicsJoint {
createJoint();
}
+ /**
+ * Create the configured joint in Bullet.
+ */
protected void createJoint() {
objectId = createJoint(nodeA.getObjectId(), nodeB.getObjectId(), pivotA, rotA, pivotB, rotB);
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Joint {0}", Long.toHexString(objectId));
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/HingeJoint.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/HingeJoint.java
index 2906d7243..609516287 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/HingeJoint.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/HingeJoint.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -42,29 +42,63 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * From bullet manual:
- * Hinge constraint, or revolute joint restricts two additional angular degrees of freedom,
- * so the body can only rotate around one axis, the hinge axis.
- * This can be useful to represent doors or wheels rotating around one axis.
- * The user can specify limits and motor for the hinge.
+ * A joint based on Bullet's btHingeConstraint.
+ *
+ * Hinge constraint, or revolute joint restricts two additional angular degrees
+ * of freedom, so the body can only rotate around one axis, the hinge axis. This
+ * can be useful to represent doors or wheels rotating around one axis. The user
+ * can specify limits and motor for the hinge.
+ *
* @author normenhansen
*/
public class HingeJoint extends PhysicsJoint {
protected Vector3f axisA;
protected Vector3f axisB;
+ /**
+ * copy of the angular-only flag (default=false)
+ */
protected boolean angularOnly = false;
+ /**
+ * copy of the limit's bias factor, how strictly position errors (drift) is
+ * corrected (default=0.3)
+ */
protected float biasFactor = 0.3f;
+ /**
+ * copy of the limit's relaxation factor, the rate at which velocity errors
+ * are corrected (default=1)
+ */
protected float relaxationFactor = 1.0f;
+ /**
+ * copy of the limit's softness, the range fraction at which velocity-error
+ * correction starts operating (default=0.9)
+ */
protected float limitSoftness = 0.9f;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public HingeJoint() {
}
/**
- * Creates a new HingeJoint
- * @param pivotA local translation of the joint connection point in node A
- * @param pivotB local translation of the joint connection point in node B
+ * Instantiate a HingeJoint. To be effective, the joint must be added to a
+ * physics space.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
+ * @param pivotA the local offset of the connection point in node A (not
+ * null, alias created)
+ * @param pivotB the local offset of the connection point in node B (not
+ * null, alias created)
+ * @param axisA the local axis of the connection to node A (not null, alias
+ * created)
+ * @param axisB the local axis of the connection to node B (not null, alias
+ * created)
*/
public HingeJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Vector3f axisA, Vector3f axisB) {
super(nodeA, nodeB, pivotA, pivotB);
@@ -74,10 +108,11 @@ public class HingeJoint extends PhysicsJoint {
}
/**
- * Enables the motor.
- * @param enable if true, motor is enabled.
- * @param targetVelocity the target velocity of the rotation.
- * @param maxMotorImpulse the max force applied to the hinge to rotate it.
+ * Enable or disable this joint's motor.
+ *
+ * @param enable true to enable, false to disable
+ * @param targetVelocity the desired target velocity
+ * @param maxMotorImpulse the desired maximum rotational force
*/
public void enableMotor(boolean enable, float targetVelocity, float maxMotorImpulse) {
enableMotor(objectId, enable, targetVelocity, maxMotorImpulse);
@@ -85,18 +120,33 @@ public class HingeJoint extends PhysicsJoint {
private native void enableMotor(long objectId, boolean enable, float targetVelocity, float maxMotorImpulse);
+ /**
+ * Test whether this joint's motor is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean getEnableMotor() {
return getEnableAngularMotor(objectId);
}
private native boolean getEnableAngularMotor(long objectId);
+ /**
+ * Read the motor's target velocity.
+ *
+ * @return velocity
+ */
public float getMotorTargetVelocity() {
return getMotorTargetVelocity(objectId);
}
private native float getMotorTargetVelocity(long objectId);
+ /**
+ * Read the motor's maximum impulse.
+ *
+ * @return impulse
+ */
public float getMaxMotorImpulse() {
return getMaxMotorImpulse(objectId);
}
@@ -104,9 +154,10 @@ public class HingeJoint extends PhysicsJoint {
private native float getMaxMotorImpulse(long objectId);
/**
- * Sets the limits of this joint.
- * @param low the low limit in radians.
- * @param high the high limit in radians.
+ * Alter this joint's limits.
+ *
+ * @param low the desired lower limit of the hinge angle (in radians)
+ * @param high the desired upper limit of the joint angle (in radians)
*/
public void setLimit(float low, float high) {
setLimit(objectId, low, high);
@@ -115,13 +166,20 @@ public class HingeJoint extends PhysicsJoint {
private native void setLimit(long objectId, float low, float high);
/**
- * Sets the limits of this joint.
- * If you're above the softness, velocities that would shoot through the actual limit are slowed down. The bias be in the range of 0.2 - 0.5.
- * @param low the low limit in radians.
- * @param high the high limit in radians.
- * @param _softness the factor at which the velocity error correction starts operating,i.e a softness of 0.9 means that the vel. corr starts at 90% of the limit range.
- * @param _biasFactor the magnitude of the position correction. It tells you how strictly the position error (drift ) is corrected.
- * @param _relaxationFactor the rate at which velocity errors are corrected. This can be seen as the strength of the limits. A low value will make the the limits more spongy.
+ * Alter this joint's limits. If you're above the softness, velocities that
+ * would shoot through the actual limit are slowed down. The bias should be
+ * in the range of 0.2 - 0.5.
+ *
+ * @param low the desired lower limit of the hinge angle (in radians)
+ * @param high the desired upper limit of the joint angle (in radians)
+ * @param _softness the desired range fraction at which velocity-error
+ * correction starts operating. A softness of 0.9 means that the correction
+ * starts at 90% of the limit range. (default=0.9)
+ * @param _biasFactor the desired magnitude of the position correction, how
+ * strictly position errors (drift) is corrected. (default=0.3)
+ * @param _relaxationFactor the desired rate at which velocity errors are
+ * corrected. This can be seen as the strength of the limits. A low value
+ * will make the limits more spongy. (default=1)
*/
public void setLimit(float low, float high, float _softness, float _biasFactor, float _relaxationFactor) {
biasFactor = _biasFactor;
@@ -132,18 +190,34 @@ public class HingeJoint extends PhysicsJoint {
private native void setLimit(long objectId, float low, float high, float _softness, float _biasFactor, float _relaxationFactor);
+ /**
+ * Read the upper limit of the hinge angle.
+ *
+ * @return angle (in radians)
+ */
public float getUpperLimit() {
return getUpperLimit(objectId);
}
private native float getUpperLimit(long objectId);
+ /**
+ * Read the lower limit of the hinge angle.
+ *
+ * @return the angle (in radians)
+ */
public float getLowerLimit() {
return getLowerLimit(objectId);
}
private native float getLowerLimit(long objectId);
+ /**
+ * Alter the hinge translation flag.
+ *
+ * @param angularOnly true→rotate only, false→rotate and translate
+ * (default=false)
+ */
public void setAngularOnly(boolean angularOnly) {
this.angularOnly = angularOnly;
setAngularOnly(objectId, angularOnly);
@@ -151,12 +225,23 @@ public class HingeJoint extends PhysicsJoint {
private native void setAngularOnly(long objectId, boolean angularOnly);
+ /**
+ * Read the hinge angle.
+ *
+ * @return the angle (in radians)
+ */
public float getHingeAngle() {
return getHingeAngle(objectId);
}
private native float getHingeAngle(long objectId);
+ /**
+ * Serialize this joint, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
super.write(ex);
OutputCapsule capsule = ex.getCapsule(this);
@@ -177,6 +262,12 @@ public class HingeJoint extends PhysicsJoint {
capsule.write(getMaxMotorImpulse(), "maxMotorImpulse", 0.0f);
}
+ /**
+ * De-serialize this joint, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
super.read(im);
InputCapsule capsule = im.getCapsule(this);
@@ -200,9 +291,13 @@ public class HingeJoint extends PhysicsJoint {
setLimit(lowerLimit, upperLimit, limitSoftness, biasFactor, relaxationFactor);
}
+ /**
+ * Create the configured joint in Bullet.
+ */
protected void createJoint() {
objectId = createJoint(nodeA.getObjectId(), nodeB.getObjectId(), pivotA, axisA, pivotB, axisB);
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Joint {0}", Long.toHexString(objectId));
+ setAngularOnly(objectId, angularOnly);
}
private native long createJoint(long objectIdA, long objectIdB, Vector3f pivotA, Vector3f axisA, Vector3f pivotB, Vector3f axisB);
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/PhysicsJoint.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/PhysicsJoint.java
index 256036ff7..f3087dfae 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/PhysicsJoint.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/PhysicsJoint.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -39,24 +39,59 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- *
- * joint has to be removed from and added to PhyiscsSpace to apply this.
- * @param collisionBetweenLinkedBodys set to false to have no collisions between linked bodys
+ * Enable or disable collisions between the linked bodies. The joint must be
+ * removed from and added to PhysicsSpace for this change to be effective.
+ *
+ * @param collisionBetweenLinkedBodys true → allow collisions, false → prevent them
*/
public void setCollisionBetweenLinkedBodys(boolean collisionBetweenLinkedBodys) {
this.collisionBetweenLinkedBodys = collisionBetweenLinkedBodys;
}
+ /**
+ * Access the 1st body specified in during construction.
+ *
+ * @return the pre-existing body
+ */
public PhysicsRigidBody getBodyA() {
return nodeA;
}
+ /**
+ * Access the 2nd body specified in during construction.
+ *
+ * @return the pre-existing body
+ */
public PhysicsRigidBody getBodyB() {
return nodeB;
}
+ /**
+ * Access the local offset of the joint connection point in node A.
+ *
+ * @return the pre-existing vector (not null)
+ */
public Vector3f getPivotA() {
return pivotA;
}
+ /**
+ * Access the local offset of the joint connection point in node A.
+ *
+ * @return the pre-existing vector (not null)
+ */
public Vector3f getPivotB() {
return pivotB;
}
/**
- * destroys this joint and removes it from its connected PhysicsRigidBodys joint lists
+ * Destroy this joint and remove it from the joint lists of its connected
+ * bodies.
*/
public void destroy() {
getBodyA().removeJoint(this);
getBodyB().removeJoint(this);
}
+ /**
+ * Serialize this joint, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
public void write(JmeExporter ex) throws IOException {
OutputCapsule capsule = ex.getCapsule(this);
capsule.write(nodeA, "nodeA", null);
@@ -128,6 +200,12 @@ public abstract class PhysicsJoint implements Savable {
capsule.write(pivotB, "pivotB", null);
}
+ /**
+ * De-serialize this joint, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
public void read(JmeImporter im) throws IOException {
InputCapsule capsule = im.getCapsule(this);
this.nodeA = ((PhysicsRigidBody) capsule.readSavable("nodeA", new PhysicsRigidBody()));
@@ -136,6 +214,12 @@ public abstract class PhysicsJoint implements Savable {
this.pivotB = (Vector3f) capsule.readSavable("pivotB", new Vector3f());
}
+ /**
+ * Finalize this physics joint just before it is destroyed. Should be
+ * invoked only by a subclass or by the garbage collector.
+ *
+ * @throws Throwable ignored by the garbage collector
+ */
@Override
protected void finalize() throws Throwable {
super.finalize();
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/Point2PointJoint.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/Point2PointJoint.java
index 312293e99..932f41f7b 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/Point2PointJoint.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/Point2PointJoint.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -42,62 +42,116 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * From bullet manual:
- * Point to point constraint, also known as ball socket joint limits the translation
- * so that the local pivot points of 2 rigidbodies match in worldspace.
- * A chain of rigidbodies can be connected using this constraint.
+ * A joint based on Bullet's btPoint2PointConstraint.
+ *
+ * Point to point constraint limits the translation so that the local pivot
+ * points of 2 rigidbodies match in worldspace. A chain of rigidbodies can be
+ * connected using this constraint.
+ *
* @author normenhansen
*/
public class Point2PointJoint extends PhysicsJoint {
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public Point2PointJoint() {
}
/**
- * @param pivotA local translation of the joint connection point in node A
- * @param pivotB local translation of the joint connection point in node B
+ * Instantiate a Point2PointJoint. To be effective, the joint must be added
+ * to a physics space.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
+ * @param pivotA the local offset of the connection point in node A (not
+ * null, alias created)
+ * @param pivotB the local offset of the connection point in node B (not
+ * null, alias created)
*/
public Point2PointJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB) {
super(nodeA, nodeB, pivotA, pivotB);
createJoint();
}
+ /**
+ * Alter the joint's damping.
+ *
+ * @param value the desired viscous damping ratio (0→no damping,
+ * 1→critically damped, default=1)
+ */
public void setDamping(float value) {
setDamping(objectId, value);
}
private native void setDamping(long objectId, float value);
+ /**
+ * Alter the joint's impulse clamp.
+ *
+ * @param value the desired impulse clamp value (default=0)
+ */
public void setImpulseClamp(float value) {
setImpulseClamp(objectId, value);
}
private native void setImpulseClamp(long objectId, float value);
+ /**
+ * Alter the joint's tau value.
+ *
+ * @param value the desired tau value (default=0.3)
+ */
public void setTau(float value) {
setTau(objectId, value);
}
private native void setTau(long objectId, float value);
+ /**
+ * Read the joint's damping ratio.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDamping() {
return getDamping(objectId);
}
private native float getDamping(long objectId);
+ /**
+ * Read the joint's impulse clamp.
+ *
+ * @return the clamp value
+ */
public float getImpulseClamp() {
return getImpulseClamp(objectId);
}
private native float getImpulseClamp(long objectId);
+ /**
+ * Read the joint's tau value.
+ *
+ * @return the tau value
+ */
public float getTau() {
return getTau(objectId);
}
private native float getTau(long objectId);
+ /**
+ * Serialize this joint, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -107,6 +161,12 @@ public class Point2PointJoint extends PhysicsJoint {
cap.write(getImpulseClamp(), "impulseClamp", 0f);
}
+ /**
+ * De-serialize this joint, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
@@ -117,6 +177,9 @@ public class Point2PointJoint extends PhysicsJoint {
setDamping(cap.readFloat("impulseClamp", 0f));
}
+ /**
+ * Create the configured joint in Bullet.
+ */
protected void createJoint() {
objectId = createJoint(nodeA.getObjectId(), nodeB.getObjectId(), pivotA, pivotB);
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Joint {0}", Long.toHexString(objectId));
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/SixDofJoint.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/SixDofJoint.java
index 648398149..660319a18 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/SixDofJoint.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/SixDofJoint.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -47,33 +47,79 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * From bullet manual:
- * This generic constraint can emulate a variety of standard constraints,
- * by configuring each of the 6 degrees of freedom (dof).
- * The first 3 dof axis are linear axis, which represent translation of rigidbodies,
- * and the latter 3 dof axis represent the angular motion. Each axis can be either locked,
- * free or limited. On construction of a new btGeneric6DofConstraint, all axis are locked.
- * Afterwards the axis can be reconfigured. Note that several combinations that
- * include free and/or limited angular degrees of freedom are undefined.
+ * A joint based on Bullet's btGeneric6DofConstraint.
+ *
+ * This generic constraint can emulate a variety of standard constraints, by
+ * configuring each of the 6 degrees of freedom (dof). The first 3 dof axis are
+ * linear axis, which represent translation of rigidbodies, and the latter 3 dof
+ * axis represent the angular motion. Each axis can be either locked, free or
+ * limited. On construction of a new btGeneric6DofSpring2Constraint, all axis
+ * are locked. Afterwards the axis can be reconfigured. Note that several
+ * combinations that include free and/or limited angular degrees of freedom are
+ * undefined.
+ *
+ *
+ *
* @author normenhansen
*/
public class SixDofJoint extends PhysicsJoint {
Matrix3f rotA, rotB;
+ /**
+ * true→limits give the allowable range of movement of frameB in frameA
+ * space, false→limits give the allowable range of movement of frameA
+ * in frameB space
+ */
boolean useLinearReferenceFrameA;
LinkedList
- * This generic constraint can emulate a variety of standard constraints,
- * by configuring each of the 6 degrees of freedom (dof).
- * The first 3 dof axis are linear axis, which represent translation of rigidbodies,
- * and the latter 3 dof axis represent the angular motion. Each axis can be either locked,
- * free or limited. On construction of a new btGeneric6DofConstraint, all axis are locked.
- * Afterwards the axis can be reconfigured. Note that several combinations that
- * include free and/or limited angular degrees of freedom are undefined.
+ * A 6 degree-of-freedom joint based on Bullet's btGeneric6DofSpringConstraint.
+ *
+ * This generic constraint can emulate a variety of standard constraints, by
+ * configuring each of the 6 degrees of freedom (dof). The first 3 dof axis are
+ * linear axis, which represent translation of rigidbodies, and the latter 3 dof
+ * axis represent the angular motion. Each axis can be either locked, free or
+ * limited. On construction of a new btGeneric6DofSpring2Constraint, all axis
+ * are locked. Afterwards the axis can be reconfigured. Note that several
+ * combinations that include free and/or limited angular degrees of freedom are
+ * undefined.
+ *
+ *
+ *
* @author normenhansen
*/
public class SixDofSpringJoint extends SixDofJoint {
@@ -53,35 +63,84 @@ public class SixDofSpringJoint extends SixDofJoint {
final float springStiffness[] = new float[6];
final float springDamping[] = new float[6]; // between 0 and 1 (1 == no damping)
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public SixDofSpringJoint() {
}
/**
- * @param pivotA local translation of the joint connection point in node A
- * @param pivotB local translation of the joint connection point in node B
+ * Instantiate a SixDofSpringJoint. To be effective, the joint must be added
+ * to a physics space.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
+ * @param pivotA the local offset of the connection point in node A (not
+ * null, alias created)
+ * @param pivotB the local offset of the connection point in node B (not
+ * null, alias created)
+ * @param rotA the local orientation of the connection to node A (not
+ * null, alias created)
+ * @param rotB the local orientation of the connection to node B (not
+ * null, alias created)
+ * @param useLinearReferenceFrameA true→use node A, false→use node
+ * B
*/
public SixDofSpringJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB, boolean useLinearReferenceFrameA) {
super(nodeA, nodeB, pivotA, pivotB, rotA, rotB, useLinearReferenceFrameA);
}
+
+ /**
+ * Enable or disable the spring for the indexed degree of freedom.
+ *
+ * @param index which degree of freedom (≥0, <6)
+ * @param onOff true → enable, false → disable
+ */
public void enableSpring(int index, boolean onOff) {
enableSpring(objectId, index, onOff);
}
native void enableSpring(long objctId, int index, boolean onOff);
+ /**
+ * Alter the spring stiffness for the indexed degree of freedom.
+ *
+ * @param index which degree of freedom (≥0, <6)
+ * @param stiffness the desired stiffness
+ */
public void setStiffness(int index, float stiffness) {
setStiffness(objectId, index, stiffness);
}
native void setStiffness(long objctId, int index, float stiffness);
+ /**
+ * Alter the damping for the indexed degree of freedom.
+ *
+ * @param index which degree of freedom (≥0, <6)
+ * @param damping the desired viscous damping ratio (0→no damping,
+ * 1→critically damped, default=1)
+ */
public void setDamping(int index, float damping) {
setDamping(objectId, index, damping);
}
native void setDamping(long objctId, int index, float damping);
+ /**
+ * Alter the equilibrium points for all degrees of freedom, based on the
+ * current constraint position/orientation.
+ */
public void setEquilibriumPoint() { // set the current constraint position/orientation as an equilibrium point for all DOF
setEquilibriumPoint(objectId);
}
native void setEquilibriumPoint(long objctId);
+ /**
+ * Alter the equilibrium point of the indexed degree of freedom, based on
+ * the current constraint position/orientation.
+ *
+ * @param index which degree of freedom (≥0, <6)
+ */
public void setEquilibriumPoint(int index){ // set the current constraint position/orientation as an equilibrium point for given DOF
setEquilibriumPoint(objectId, index);
}
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/SliderJoint.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/SliderJoint.java
index b51c5d849..8299fbd65 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/SliderJoint.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/SliderJoint.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -43,8 +43,12 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * From bullet manual:
- * The slider constraint allows the body to rotate around one axis and translate along this axis.
+ * A slider joint based on Bullet's btSliderConstraint.
+ *
+ * The slider constraint allows the body to rotate around one axis and translate
+ * along this axis.
+ *
* @author normenhansen
*/
public class SliderJoint extends PhysicsJoint {
@@ -52,12 +56,29 @@ public class SliderJoint extends PhysicsJoint {
protected Matrix3f rotA, rotB;
protected boolean useLinearReferenceFrameA;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public SliderJoint() {
}
/**
- * @param pivotA local translation of the joint connection point in node A
- * @param pivotB local translation of the joint connection point in node B
+ * Instantiate a SliderJoint. To be effective, the joint must be added to a
+ * physics space.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
+ * @param pivotA the local offset of the connection point in node A (not
+ * null, alias created)
+ * @param pivotB the local offset of the connection point in node B (not
+ * null, alias created)
+ * @param rotA the local orientation of the connection to node A (not null, alias created)
+ * @param rotB the local orientation of the connection to node B (not null, alias created)
+ * @param useLinearReferenceFrameA true→use node A, false→use node
+ * B
*/
public SliderJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB, boolean useLinearReferenceFrameA) {
super(nodeA, nodeB, pivotA, pivotB);
@@ -68,8 +89,19 @@ public class SliderJoint extends PhysicsJoint {
}
/**
- * @param pivotA local translation of the joint connection point in node A
- * @param pivotB local translation of the joint connection point in node B
+ * Instantiate a SliderJoint. To be effective, the joint must be added to a
+ * physics space.
+ *
+ * @param nodeA the 1st body connected by the joint (not null, alias
+ * created)
+ * @param nodeB the 2nd body connected by the joint (not null, alias
+ * created)
+ * @param pivotA the local offset of the connection point in node A (not
+ * null, alias created)
+ * @param pivotB the local offset of the connection point in node B (not
+ * null, alias created)
+ * @param useLinearReferenceFrameA true→use node A, false→use node
+ * B
*/
public SliderJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, boolean useLinearReferenceFrameA) {
super(nodeA, nodeB, pivotA, pivotB);
@@ -79,342 +111,651 @@ public class SliderJoint extends PhysicsJoint {
createJoint();
}
+ /**
+ * Read the joint's lower limit for on-axis translation.
+ *
+ * @return the lower limit
+ */
public float getLowerLinLimit() {
return getLowerLinLimit(objectId);
}
private native float getLowerLinLimit(long objectId);
+ /**
+ * Alter the joint's lower limit for on-axis translation.
+ *
+ * @param lowerLinLimit the desired lower limit (default=-1)
+ */
public void setLowerLinLimit(float lowerLinLimit) {
setLowerLinLimit(objectId, lowerLinLimit);
}
private native void setLowerLinLimit(long objectId, float value);
+ /**
+ * Read the joint's upper limit for on-axis translation.
+ *
+ * @return the upper limit
+ */
public float getUpperLinLimit() {
return getUpperLinLimit(objectId);
}
private native float getUpperLinLimit(long objectId);
+ /**
+ * Alter the joint's upper limit for on-axis translation.
+ *
+ * @param upperLinLimit the desired upper limit (default=1)
+ */
public void setUpperLinLimit(float upperLinLimit) {
setUpperLinLimit(objectId, upperLinLimit);
}
private native void setUpperLinLimit(long objectId, float value);
+ /**
+ * Read the joint's lower limit for on-axis rotation.
+ *
+ * @return the lower limit angle (in radians)
+ */
public float getLowerAngLimit() {
return getLowerAngLimit(objectId);
}
private native float getLowerAngLimit(long objectId);
+ /**
+ * Alter the joint's lower limit for on-axis rotation.
+ *
+ * @param lowerAngLimit the desired lower limit angle (in radians,
+ * default=0)
+ */
public void setLowerAngLimit(float lowerAngLimit) {
setLowerAngLimit(objectId, lowerAngLimit);
}
private native void setLowerAngLimit(long objectId, float value);
+ /**
+ * Read the joint's upper limit for on-axis rotation.
+ *
+ * @return the upper limit angle (in radians)
+ */
public float getUpperAngLimit() {
return getUpperAngLimit(objectId);
}
private native float getUpperAngLimit(long objectId);
+ /**
+ * Alter the joint's upper limit for on-axis rotation.
+ *
+ * @param upperAngLimit the desired upper limit angle (in radians,
+ * default=0)
+ */
public void setUpperAngLimit(float upperAngLimit) {
setUpperAngLimit(objectId, upperAngLimit);
}
private native void setUpperAngLimit(long objectId, float value);
+ /**
+ * Read the joint's softness for on-axis translation between the limits.
+ *
+ * @return the softness
+ */
public float getSoftnessDirLin() {
return getSoftnessDirLin(objectId);
}
private native float getSoftnessDirLin(long objectId);
+ /**
+ * Alter the joint's softness for on-axis translation between the limits.
+ *
+ * @param softnessDirLin the desired softness (default=1)
+ */
public void setSoftnessDirLin(float softnessDirLin) {
setSoftnessDirLin(objectId, softnessDirLin);
}
private native void setSoftnessDirLin(long objectId, float value);
+ /**
+ * Read the joint's restitution for on-axis translation between the limits.
+ *
+ * @return the restitution (bounce) factor
+ */
public float getRestitutionDirLin() {
return getRestitutionDirLin(objectId);
}
private native float getRestitutionDirLin(long objectId);
+ /**
+ * Alter the joint's restitution for on-axis translation between the limits.
+ *
+ * @param restitutionDirLin the desired restitution (bounce) factor
+ * (default=0.7)
+ */
public void setRestitutionDirLin(float restitutionDirLin) {
setRestitutionDirLin(objectId, restitutionDirLin);
}
private native void setRestitutionDirLin(long objectId, float value);
+ /**
+ * Read the joint's damping for on-axis translation between the limits.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDampingDirLin() {
return getDampingDirLin(objectId);
}
private native float getDampingDirLin(long objectId);
+ /**
+ * Alter the joint's damping for on-axis translation between the limits.
+ *
+ * @param dampingDirLin the desired viscous damping ratio (0→no
+ * damping, 1→critically damped, default=0)
+ */
public void setDampingDirLin(float dampingDirLin) {
setDampingDirLin(objectId, dampingDirLin);
}
private native void setDampingDirLin(long objectId, float value);
+ /**
+ * Read the joint's softness for on-axis rotation between the limits.
+ *
+ * @return the softness
+ */
public float getSoftnessDirAng() {
return getSoftnessDirAng(objectId);
}
private native float getSoftnessDirAng(long objectId);
+ /**
+ * Alter the joint's softness for on-axis rotation between the limits.
+ *
+ * @param softnessDirAng the desired softness (default=1)
+ */
public void setSoftnessDirAng(float softnessDirAng) {
setSoftnessDirAng(objectId, softnessDirAng);
}
private native void setSoftnessDirAng(long objectId, float value);
+ /**
+ * Read the joint's restitution for on-axis rotation between the limits.
+ *
+ * @return the restitution (bounce) factor
+ */
public float getRestitutionDirAng() {
return getRestitutionDirAng(objectId);
}
private native float getRestitutionDirAng(long objectId);
+ /**
+ * Alter the joint's restitution for on-axis rotation between the limits.
+ *
+ * @param restitutionDirAng the desired restitution (bounce) factor
+ * (default=0.7)
+ */
public void setRestitutionDirAng(float restitutionDirAng) {
setRestitutionDirAng(objectId, restitutionDirAng);
}
private native void setRestitutionDirAng(long objectId, float value);
+ /**
+ * Read the joint's damping for on-axis rotation between the limits.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDampingDirAng() {
return getDampingDirAng(objectId);
}
private native float getDampingDirAng(long objectId);
+ /**
+ * Alter the joint's damping for on-axis rotation between the limits.
+ *
+ * @param dampingDirAng the desired viscous damping ratio (0→no
+ * damping, 1→critically damped, default=0)
+ */
public void setDampingDirAng(float dampingDirAng) {
setDampingDirAng(objectId, dampingDirAng);
}
private native void setDampingDirAng(long objectId, float value);
+ /**
+ * Read the joint's softness for on-axis translation hitting the limits.
+ *
+ * @return the softness
+ */
public float getSoftnessLimLin() {
return getSoftnessLimLin(objectId);
}
private native float getSoftnessLimLin(long objectId);
+ /**
+ * Alter the joint's softness for on-axis translation hitting the limits.
+ *
+ * @param softnessLimLin the desired softness (default=1)
+ */
public void setSoftnessLimLin(float softnessLimLin) {
setSoftnessLimLin(objectId, softnessLimLin);
}
private native void setSoftnessLimLin(long objectId, float value);
+ /**
+ * Read the joint's restitution for on-axis translation hitting the limits.
+ *
+ * @return the restitution (bounce) factor
+ */
public float getRestitutionLimLin() {
return getRestitutionLimLin(objectId);
}
private native float getRestitutionLimLin(long objectId);
+ /**
+ * Alter the joint's restitution for on-axis translation hitting the limits.
+ *
+ * @param restitutionLimLin the desired restitution (bounce) factor
+ * (default=0.7)
+ */
public void setRestitutionLimLin(float restitutionLimLin) {
setRestitutionLimLin(objectId, restitutionLimLin);
}
private native void setRestitutionLimLin(long objectId, float value);
+ /**
+ * Read the joint's damping for on-axis translation hitting the limits.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDampingLimLin() {
return getDampingLimLin(objectId);
}
private native float getDampingLimLin(long objectId);
+ /**
+ * Alter the joint's damping for on-axis translation hitting the limits.
+ *
+ * @param dampingLimLin the desired viscous damping ratio (0→no
+ * damping, 1→critically damped, default=1)
+ */
public void setDampingLimLin(float dampingLimLin) {
setDampingLimLin(objectId, dampingLimLin);
}
private native void setDampingLimLin(long objectId, float value);
+ /**
+ * Read the joint's softness for on-axis rotation hitting the limits.
+ *
+ * @return the softness
+ */
public float getSoftnessLimAng() {
return getSoftnessLimAng(objectId);
}
private native float getSoftnessLimAng(long objectId);
+ /**
+ * Alter the joint's softness for on-axis rotation hitting the limits.
+ *
+ * @param softnessLimAng the desired softness (default=1)
+ */
public void setSoftnessLimAng(float softnessLimAng) {
setSoftnessLimAng(objectId, softnessLimAng);
}
private native void setSoftnessLimAng(long objectId, float value);
+ /**
+ * Read the joint's restitution for on-axis rotation hitting the limits.
+ *
+ * @return the restitution (bounce) factor
+ */
public float getRestitutionLimAng() {
return getRestitutionLimAng(objectId);
}
private native float getRestitutionLimAng(long objectId);
+ /**
+ * Alter the joint's restitution for on-axis rotation hitting the limits.
+ *
+ * @param restitutionLimAng the desired restitution (bounce) factor
+ * (default=0.7)
+ */
public void setRestitutionLimAng(float restitutionLimAng) {
setRestitutionLimAng(objectId, restitutionLimAng);
}
private native void setRestitutionLimAng(long objectId, float value);
+ /**
+ * Read the joint's damping for on-axis rotation hitting the limits.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDampingLimAng() {
return getDampingLimAng(objectId);
}
private native float getDampingLimAng(long objectId);
+ /**
+ * Alter the joint's damping for on-axis rotation hitting the limits.
+ *
+ * @param dampingLimAng the desired viscous damping ratio (0→no
+ * damping, 1→critically damped, default=1)
+ */
public void setDampingLimAng(float dampingLimAng) {
setDampingLimAng(objectId, dampingLimAng);
}
private native void setDampingLimAng(long objectId, float value);
+ /**
+ * Read the joint's softness for off-axis translation.
+ *
+ * @return the softness
+ */
public float getSoftnessOrthoLin() {
return getSoftnessOrthoLin(objectId);
}
private native float getSoftnessOrthoLin(long objectId);
+ /**
+ * Alter the joint's softness for off-axis translation.
+ *
+ * @param softnessOrthoLin the desired softness (default=1)
+ */
public void setSoftnessOrthoLin(float softnessOrthoLin) {
setSoftnessOrthoLin(objectId, softnessOrthoLin);
}
private native void setSoftnessOrthoLin(long objectId, float value);
+ /**
+ * Read the joint's restitution for off-axis translation.
+ *
+ * @return the restitution (bounce) factor
+ */
public float getRestitutionOrthoLin() {
return getRestitutionOrthoLin(objectId);
}
private native float getRestitutionOrthoLin(long objectId);
+ /**
+ * Alter the joint's restitution for off-axis translation.
+ *
+ * @param restitutionOrthoLin the desired restitution (bounce) factor
+ * (default=0.7)
+ */
public void setRestitutionOrthoLin(float restitutionOrthoLin) {
- setDampingOrthoLin(objectId, restitutionOrthoLin);
+ setRestitutionOrthoLin(objectId, restitutionOrthoLin);
}
private native void setRestitutionOrthoLin(long objectId, float value);
+ /**
+ * Read the joint's damping for off-axis translation.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDampingOrthoLin() {
return getDampingOrthoLin(objectId);
}
private native float getDampingOrthoLin(long objectId);
+ /**
+ * Alter the joint's damping for off-axis translation.
+ *
+ * @param dampingOrthoLin the desired viscous damping ratio (0→no
+ * damping, 1→critically damped, default=1)
+ */
public void setDampingOrthoLin(float dampingOrthoLin) {
setDampingOrthoLin(objectId, dampingOrthoLin);
}
private native void setDampingOrthoLin(long objectId, float value);
+ /**
+ * Read the joint's softness for off-axis rotation.
+ *
+ * @return the softness
+ */
public float getSoftnessOrthoAng() {
return getSoftnessOrthoAng(objectId);
}
private native float getSoftnessOrthoAng(long objectId);
+ /**
+ * Alter the joint's softness for off-axis rotation.
+ *
+ * @param softnessOrthoAng the desired softness (default=1)
+ */
public void setSoftnessOrthoAng(float softnessOrthoAng) {
setSoftnessOrthoAng(objectId, softnessOrthoAng);
}
private native void setSoftnessOrthoAng(long objectId, float value);
+ /**
+ * Read the joint's restitution for off-axis rotation.
+ *
+ * @return the restitution (bounce) factor
+ */
public float getRestitutionOrthoAng() {
return getRestitutionOrthoAng(objectId);
}
private native float getRestitutionOrthoAng(long objectId);
+ /**
+ * Alter the joint's restitution for off-axis rotation.
+ *
+ * @param restitutionOrthoAng the desired restitution (bounce) factor
+ * (default=0.7)
+ */
public void setRestitutionOrthoAng(float restitutionOrthoAng) {
setRestitutionOrthoAng(objectId, restitutionOrthoAng);
}
private native void setRestitutionOrthoAng(long objectId, float value);
+ /**
+ * Read the joint's damping for off-axis rotation.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDampingOrthoAng() {
return getDampingOrthoAng(objectId);
}
private native float getDampingOrthoAng(long objectId);
+ /**
+ * Alter the joint's damping for off-axis rotation.
+ *
+ * @param dampingOrthoAng the desired viscous damping ratio (0→no
+ * damping, 1→critically damped, default=1)
+ */
public void setDampingOrthoAng(float dampingOrthoAng) {
setDampingOrthoAng(objectId, dampingOrthoAng);
}
private native void setDampingOrthoAng(long objectId, float value);
+ /**
+ * Test whether the translation motor is powered.
+ *
+ * @return true if powered, otherwise false
+ */
public boolean isPoweredLinMotor() {
return isPoweredLinMotor(objectId);
}
private native boolean isPoweredLinMotor(long objectId);
+ /**
+ * Alter whether the translation motor is powered.
+ *
+ * @param poweredLinMotor true to power the motor, false to de-power it
+ * (default=false)
+ */
public void setPoweredLinMotor(boolean poweredLinMotor) {
setPoweredLinMotor(objectId, poweredLinMotor);
}
private native void setPoweredLinMotor(long objectId, boolean value);
+ /**
+ * Read the velocity target of the translation motor.
+ *
+ * @return the velocity target
+ */
public float getTargetLinMotorVelocity() {
return getTargetLinMotorVelocity(objectId);
}
private native float getTargetLinMotorVelocity(long objectId);
+ /**
+ * Alter the velocity target of the translation motor.
+ *
+ * @param targetLinMotorVelocity the desired velocity target (default=0)
+ */
public void setTargetLinMotorVelocity(float targetLinMotorVelocity) {
setTargetLinMotorVelocity(objectId, targetLinMotorVelocity);
}
private native void setTargetLinMotorVelocity(long objectId, float value);
+ /**
+ * Read the maximum force of the translation motor.
+ *
+ * @return the maximum force
+ */
public float getMaxLinMotorForce() {
return getMaxLinMotorForce(objectId);
}
private native float getMaxLinMotorForce(long objectId);
+ /**
+ * Alter the maximum force of the translation motor.
+ *
+ * @param maxLinMotorForce the desired maximum force (default=0)
+ */
public void setMaxLinMotorForce(float maxLinMotorForce) {
setMaxLinMotorForce(objectId, maxLinMotorForce);
}
private native void setMaxLinMotorForce(long objectId, float value);
+ /**
+ * Test whether the rotation motor is powered.
+ *
+ * @return true if powered, otherwise false
+ */
public boolean isPoweredAngMotor() {
return isPoweredAngMotor(objectId);
}
private native boolean isPoweredAngMotor(long objectId);
+ /**
+ * Alter whether the rotation motor is powered.
+ *
+ * @param poweredAngMotor true to power the motor, false to de-power it
+ * (default=false)
+ */
public void setPoweredAngMotor(boolean poweredAngMotor) {
setPoweredAngMotor(objectId, poweredAngMotor);
}
private native void setPoweredAngMotor(long objectId, boolean value);
+ /**
+ * Read the velocity target of the rotation motor.
+ *
+ * @return the velocity target (in radians per second)
+ */
public float getTargetAngMotorVelocity() {
return getTargetAngMotorVelocity(objectId);
}
private native float getTargetAngMotorVelocity(long objectId);
+ /**
+ * Alter the velocity target of the rotation motor.
+ *
+ * @param targetAngMotorVelocity the desired velocity target (in radians per
+ * second, default=0)
+ */
public void setTargetAngMotorVelocity(float targetAngMotorVelocity) {
setTargetAngMotorVelocity(objectId, targetAngMotorVelocity);
}
private native void setTargetAngMotorVelocity(long objectId, float value);
+ /**
+ * Read the maximum force of the rotation motor.
+ *
+ * @return the maximum force
+ */
public float getMaxAngMotorForce() {
return getMaxAngMotorForce(objectId);
}
private native float getMaxAngMotorForce(long objectId);
+ /**
+ * Alter the maximum force of the rotation motor.
+ *
+ * @param maxAngMotorForce the desired maximum force (default=0)
+ */
public void setMaxAngMotorForce(float maxAngMotorForce) {
setMaxAngMotorForce(objectId, maxAngMotorForce);
}
private native void setMaxAngMotorForce(long objectId, float value);
+ /**
+ * Serialize this joint, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
super.write(ex);
@@ -455,6 +796,12 @@ public class SliderJoint extends PhysicsJoint {
capsule.write(useLinearReferenceFrameA, "useLinearReferenceFrameA", false);
}
+ /**
+ * De-serialize this joint, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
super.read(im);
@@ -528,6 +875,9 @@ public class SliderJoint extends PhysicsJoint {
setUpperLinLimit(upperLinLimit);
}
+ /**
+ * Instantiate the configured constraint in Bullet.
+ */
protected void createJoint() {
objectId = createJoint(nodeA.getObjectId(), nodeB.getObjectId(), pivotA, rotA, pivotB, rotB, useLinearReferenceFrameA);
Logger.getLogger(this.getClass().getName()).log(Level.FINE, "Created Joint {0}", Long.toHexString(objectId));
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/RotationalLimitMotor.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/RotationalLimitMotor.java
index 4b4b4aa95..88db32aba 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/RotationalLimitMotor.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/RotationalLimitMotor.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,135 +32,253 @@
package com.jme3.bullet.joints.motors;
/**
+ * A motor based on Bullet's btRotationalLimitMotor. Motors are used to drive
+ * joints.
*
* @author normenhansen
*/
public class RotationalLimitMotor {
+ /**
+ * Unique identifier of the btRotationalLimitMotor. The constructor sets
+ * this to a non-zero value.
+ */
private long motorId = 0;
+ /**
+ * Instantiate a motor for the identified btRotationalLimitMotor.
+ *
+ * @param motor the unique identifier (not zero)
+ */
public RotationalLimitMotor(long motor) {
this.motorId = motor;
}
+ /**
+ * Read the id of the btRotationalLimitMotor.
+ *
+ * @return the identifier of the btRotationalLimitMotor (not zero)
+ */
public long getMotor() {
return motorId;
}
+ /**
+ * Read this motor's constraint lower limit.
+ *
+ * @return the limit value
+ */
public float getLoLimit() {
return getLoLimit(motorId);
}
private native float getLoLimit(long motorId);
+ /**
+ * Alter this motor's constraint lower limit.
+ *
+ * @param loLimit the desired limit value
+ */
public void setLoLimit(float loLimit) {
setLoLimit(motorId, loLimit);
}
private native void setLoLimit(long motorId, float loLimit);
+ /**
+ * Read this motor's constraint upper limit.
+ *
+ * @return the limit value
+ */
public float getHiLimit() {
return getHiLimit(motorId);
}
private native float getHiLimit(long motorId);
+ /**
+ * Alter this motor's constraint upper limit.
+ *
+ * @param hiLimit the desired limit value
+ */
public void setHiLimit(float hiLimit) {
setHiLimit(motorId, hiLimit);
}
private native void setHiLimit(long motorId, float hiLimit);
+ /**
+ * Read this motor's target velocity.
+ *
+ * @return the target velocity (in radians per second)
+ */
public float getTargetVelocity() {
return getTargetVelocity(motorId);
}
private native float getTargetVelocity(long motorId);
+ /**
+ * Alter this motor's target velocity.
+ *
+ * @param targetVelocity the desired target velocity (in radians per second)
+ */
public void setTargetVelocity(float targetVelocity) {
setTargetVelocity(motorId, targetVelocity);
}
private native void setTargetVelocity(long motorId, float targetVelocity);
+ /**
+ * Read this motor's maximum force.
+ *
+ * @return the maximum force
+ */
public float getMaxMotorForce() {
return getMaxMotorForce(motorId);
}
private native float getMaxMotorForce(long motorId);
+ /**
+ * Alter this motor's maximum force.
+ *
+ * @param maxMotorForce the desired maximum force on the motor
+ */
public void setMaxMotorForce(float maxMotorForce) {
setMaxMotorForce(motorId, maxMotorForce);
}
private native void setMaxMotorForce(long motorId, float maxMotorForce);
+ /**
+ * Read the limit's maximum force.
+ *
+ * @return the maximum force on the limit
+ */
public float getMaxLimitForce() {
return getMaxLimitForce(motorId);
}
private native float getMaxLimitForce(long motorId);
+ /**
+ * Alter the limit's maximum force.
+ *
+ * @param maxLimitForce the desired maximum force on the limit
+ */
public void setMaxLimitForce(float maxLimitForce) {
setMaxLimitForce(motorId, maxLimitForce);
}
private native void setMaxLimitForce(long motorId, float maxLimitForce);
+ /**
+ * Read this motor's damping.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDamping() {
return getDamping(motorId);
}
private native float getDamping(long motorId);
+ /**
+ * Alter this motor's damping.
+ *
+ * @param damping the desired viscous damping ratio (0→no damping,
+ * 1→critically damped, default=1)
+ */
public void setDamping(float damping) {
setDamping(motorId, damping);
}
private native void setDamping(long motorId, float damping);
+ /**
+ * Read this motor's limit softness.
+ *
+ * @return the limit softness
+ */
public float getLimitSoftness() {
return getLimitSoftness(motorId);
}
private native float getLimitSoftness(long motorId);
+ /**
+ * Alter this motor's limit softness.
+ *
+ * @param limitSoftness the desired limit softness
+ */
public void setLimitSoftness(float limitSoftness) {
setLimitSoftness(motorId, limitSoftness);
}
private native void setLimitSoftness(long motorId, float limitSoftness);
+ /**
+ * Read this motor's error tolerance at limits.
+ *
+ * @return the error tolerance (>0)
+ */
public float getERP() {
return getERP(motorId);
}
private native float getERP(long motorId);
+ /**
+ * Alter this motor's error tolerance at limits.
+ *
+ * @param ERP the desired error tolerance (>0)
+ */
public void setERP(float ERP) {
setERP(motorId, ERP);
}
private native void setERP(long motorId, float ERP);
+ /**
+ * Read this motor's bounce.
+ *
+ * @return the bounce (restitution factor)
+ */
public float getBounce() {
return getBounce(motorId);
}
private native float getBounce(long motorId);
+ /**
+ * Alter this motor's bounce.
+ *
+ * @param bounce the desired bounce (restitution factor)
+ */
public void setBounce(float bounce) {
setBounce(motorId, bounce);
}
private native void setBounce(long motorId, float limitSoftness);
+ /**
+ * Test whether this motor is enabled.
+ *
+ * @return true if enabled, otherwise false
+ */
public boolean isEnableMotor() {
return isEnableMotor(motorId);
}
private native boolean isEnableMotor(long motorId);
+ /**
+ * Enable or disable this motor.
+ *
+ * @param enableMotor true→enable, false→disable
+ */
public void setEnableMotor(boolean enableMotor) {
setEnableMotor(motorId, enableMotor);
}
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/TranslationalLimitMotor.java b/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/TranslationalLimitMotor.java
index 3b7690697..97993edd3 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/TranslationalLimitMotor.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/joints/motors/TranslationalLimitMotor.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -34,21 +34,42 @@ package com.jme3.bullet.joints.motors;
import com.jme3.math.Vector3f;
/**
+ * A motor based on Bullet's btTranslationalLimitMotor. Motors are used to drive
+ * joints.
*
* @author normenhansen
*/
public class TranslationalLimitMotor {
+ /**
+ * Unique identifier of the btTranslationalLimitMotor. The constructor sets
+ * this to a non-zero value. After that, the id never changes.
+ */
private long motorId = 0;
+ /**
+ * Instantiate a motor for the identified btTranslationalLimitMotor.
+ *
+ * @param motor the unique identifier (not zero)
+ */
public TranslationalLimitMotor(long motor) {
this.motorId = motor;
}
+ /**
+ * Read the id of the btTranslationalLimitMotor.
+ *
+ * @return the unique identifier (not zero)
+ */
public long getMotor() {
return motorId;
}
+ /**
+ * Copy this motor's constraint lower limits.
+ *
+ * @return a new vector (not null)
+ */
public Vector3f getLowerLimit() {
Vector3f vec = new Vector3f();
getLowerLimit(motorId, vec);
@@ -57,12 +78,22 @@ public class TranslationalLimitMotor {
private native void getLowerLimit(long motorId, Vector3f vector);
+ /**
+ * Alter the constraint lower limits.
+ *
+ * @param lowerLimit (unaffected, not null)
+ */
public void setLowerLimit(Vector3f lowerLimit) {
setLowerLimit(motorId, lowerLimit);
}
private native void setLowerLimit(long motorId, Vector3f vector);
+ /**
+ * Copy this motor's constraint upper limits.
+ *
+ * @return a new vector (not null)
+ */
public Vector3f getUpperLimit() {
Vector3f vec = new Vector3f();
getUpperLimit(motorId, vec);
@@ -71,12 +102,22 @@ public class TranslationalLimitMotor {
private native void getUpperLimit(long motorId, Vector3f vector);
+ /**
+ * Alter the constraint upper limits.
+ *
+ * @param upperLimit (unaffected, not null)
+ */
public void setUpperLimit(Vector3f upperLimit) {
setUpperLimit(motorId, upperLimit);
}
private native void setUpperLimit(long motorId, Vector3f vector);
+ /**
+ * Copy the accumulated impulse.
+ *
+ * @return a new vector (not null)
+ */
public Vector3f getAccumulatedImpulse() {
Vector3f vec = new Vector3f();
getAccumulatedImpulse(motorId, vec);
@@ -85,42 +126,79 @@ public class TranslationalLimitMotor {
private native void getAccumulatedImpulse(long motorId, Vector3f vector);
+ /**
+ * Alter the accumulated impulse.
+ *
+ * @param accumulatedImpulse the desired vector (not null, unaffected)
+ */
public void setAccumulatedImpulse(Vector3f accumulatedImpulse) {
setAccumulatedImpulse(motorId, accumulatedImpulse);
}
private native void setAccumulatedImpulse(long motorId, Vector3f vector);
+ /**
+ * Read this motor's limit softness.
+ *
+ * @return the softness
+ */
public float getLimitSoftness() {
return getLimitSoftness(motorId);
}
private native float getLimitSoftness(long motorId);
+ /**
+ * Alter the limit softness.
+ *
+ * @param limitSoftness the desired limit softness (default=0.5)
+ */
public void setLimitSoftness(float limitSoftness) {
setLimitSoftness(motorId, limitSoftness);
}
private native void setLimitSoftness(long motorId, float limitSoftness);
+ /**
+ * Read this motor's damping.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getDamping() {
return getDamping(motorId);
}
private native float getDamping(long motorId);
+ /**
+ * Alter this motor's damping.
+ *
+ * @param damping the desired viscous damping ratio (0→no damping,
+ * 1→critically damped, default=1)
+ */
public void setDamping(float damping) {
setDamping(motorId, damping);
}
private native void setDamping(long motorId, float damping);
+ /**
+ * Read this motor's restitution.
+ *
+ * @return the restitution (bounce) factor
+ */
public float getRestitution() {
return getRestitution(motorId);
}
private native float getRestitution(long motorId);
+ /**
+ * Alter this motor's restitution.
+ *
+ * @param restitution the desired restitution (bounce) factor
+ */
public void setRestitution(float restitution) {
setRestitution(motorId, restitution);
}
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsCharacter.java b/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsCharacter.java
index bf55a2909..756c0a8d9 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsCharacter.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/objects/PhysicsCharacter.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -31,6 +31,7 @@
*/
package com.jme3.bullet.objects;
+import com.jme3.bullet.collision.CollisionFlag;
import com.jme3.bullet.collision.PhysicsCollisionObject;
import com.jme3.bullet.collision.shapes.CollisionShape;
import com.jme3.export.InputCapsule;
@@ -44,11 +45,18 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * Basic Bullet Character
+ * A collision object for simplified character simulation, based on Bullet's
+ * btKinematicCharacterController.
+ *
* @author normenhansen
*/
public class PhysicsCharacter extends PhysicsCollisionObject {
-
+ /**
+ * Unique identifier of btKinematicCharacterController (as opposed to its
+ * collision object, which is a ghost). Constructors are responsible for
+ * setting this to a non-zero value. The id might change if the character
+ * gets rebuilt.
+ */
protected long characterId = 0;
protected float stepHeight;
protected Vector3f walkDirection = new Vector3f();
@@ -59,12 +67,19 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
//TEMP VARIABLES
protected final Quaternion tmp_inverseWorldRotation = new Quaternion();
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public PhysicsCharacter() {
}
/**
- * @param shape The CollisionShape (no Mesh or CompoundCollisionShapes)
- * @param stepHeight The quantization size for vertical movement
+ * Instantiate a character with the specified collision shape and step
+ * height.
+ *
+ * @param shape the desired shape (not null, alias created)
+ * @param stepHeight the quantization size for vertical movement
*/
public PhysicsCharacter(CollisionShape shape, float stepHeight) {
this.collisionShape = shape;
@@ -75,6 +90,9 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
buildObject();
}
+ /**
+ * Create the configured character in Bullet.
+ */
protected void buildObject() {
if (objectId == 0) {
objectId = createGhostObject();
@@ -98,8 +116,9 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native long createCharacterObject(long objectId, long shapeId, float stepHeight);
/**
- * Sets the location of this physics character
- * @param location
+ * Directly alter the location of this character's center of mass.
+ *
+ * @param location the desired physics location (not null, unaffected)
*/
public void warp(Vector3f location) {
warp(characterId, location);
@@ -108,11 +127,11 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void warp(long characterId, Vector3f location);
/**
- * Set the walk direction, works continuously.
- * This should probably be called setPositionIncrementPerSimulatorStep.
- * This is neither a direction nor a velocity, but the amount to
- * increment the position each physics tick. So vector length = accuracy*speed in m/s
- * @param vec the walk direction to set
+ * Alter the walk offset. The offset will continue to be applied until
+ * altered again.
+ *
+ * @param vec the desired position increment for each physics tick (not
+ * null, unaffected)
*/
public void setWalkDirection(Vector3f vec) {
walkDirection.set(vec);
@@ -122,7 +141,9 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setWalkDirection(long characterId, Vector3f vec);
/**
- * @return the currently set walkDirection
+ * Access the walk offset.
+ *
+ * @return the pre-existing instance
*/
public Vector3f getWalkDirection() {
return walkDirection;
@@ -130,6 +151,7 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
/**
* @deprecated Deprecated in bullet 2.86.1 use setUp(Vector3f) instead
+ * @param axis which axis: 0→X, 1→Y, 2→Z
*/
@Deprecated
public void setUpAxis(int axis) {
@@ -147,6 +169,11 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
}
}
+ /**
+ * Alter this character's "up" direction.
+ *
+ * @param axis the desired direction (not null, not zero, unaffected)
+ */
public void setUp(Vector3f axis) {
setUp(characterId, axis);
}
@@ -154,6 +181,11 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setUp(long characterId, Vector3f axis);
+ /**
+ * Alter this character's angular velocity.
+ *
+ * @param v the desired angular velocity vector (not null, unaffected)
+ */
public void setAngularVelocity(Vector3f v){
setAngularVelocity(characterId,v);
@@ -161,7 +193,13 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setAngularVelocity(long characterId, Vector3f v);
-
+ /**
+ * Copy this character's angular velocity.
+ *
+ * @param out storage for the result (modified if not null)
+ * @return the velocity vector (either the provided storage or a new vector,
+ * not null)
+ */
public Vector3f getAngularVelocity(Vector3f out){
if(out==null)out=new Vector3f();
getAngularVelocity(characterId,out);
@@ -171,13 +209,23 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void getAngularVelocity(long characterId, Vector3f out);
+ /**
+ * Alter the linear velocity of this character's center of mass.
+ *
+ * @param v the desired velocity vector (not null)
+ */
public void setLinearVelocity(Vector3f v){
setLinearVelocity(characterId,v);
}
private native void setLinearVelocity(long characterId, Vector3f v);
-
+ /**
+ * Copy the linear velocity of this character's center of mass.
+ *
+ * @param out storage for the result (modified if not null)
+ * @return a vector (either the provided storage or a new vector, not null)
+ */
public Vector3f getLinearVelocity(Vector3f out){
if(out==null)out=new Vector3f();
getLinearVelocity(characterId,out);
@@ -187,10 +235,20 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void getLinearVelocity(long characterId, Vector3f out);
+ /**
+ * Read the index of the "up" axis.
+ *
+ * @return which axis: 0→X, 1→Y, 2→Z
+ */
public int getUpAxis() {
return upAxis;
}
+ /**
+ * Alter this character's fall speed.
+ *
+ * @param fallSpeed the desired speed (default=55)
+ */
public void setFallSpeed(float fallSpeed) {
this.fallSpeed = fallSpeed;
setFallSpeed(characterId, fallSpeed);
@@ -198,10 +256,20 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setFallSpeed(long characterId, float fallSpeed);
+ /**
+ * Read this character's fall speed.
+ *
+ * @return speed
+ */
public float getFallSpeed() {
return fallSpeed;
}
+ /**
+ * Alter this character's jump speed.
+ *
+ * @param jumpSpeed the desired speed (default=10)
+ */
public void setJumpSpeed(float jumpSpeed) {
this.jumpSpeed = jumpSpeed;
setJumpSpeed(characterId, jumpSpeed);
@@ -209,18 +277,31 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setJumpSpeed(long characterId, float jumpSpeed);
+ /**
+ * Read this character's jump speed.
+ *
+ * @return speed
+ */
public float getJumpSpeed() {
return jumpSpeed;
}
/**
- * @deprecated Deprecated in bullet 2.86.1. Use setGravity(Vector3f) instead.
+ * @deprecated Deprecated in bullet 2.86.1. Use setGravity(Vector3f)
+ * instead.
+ * @param value the desired upward component of the acceleration (typically
+ * negative)
*/
@Deprecated
public void setGravity(float value) {
setGravity(new Vector3f(0,value,0));
}
+ /**
+ * Alter this character's gravitational acceleration.
+ *
+ * @param value the desired acceleration vector (not null, unaffected)
+ */
public void setGravity(Vector3f value) {
setGravity(characterId, value);
}
@@ -228,13 +309,22 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setGravity(long characterId, Vector3f gravity);
/**
- * @deprecated Deprecated in bullet 2.86.1. Use getGravity(Vector3f) instead.
+ * @deprecated Deprecated in bullet 2.86.1. Use getGravity(Vector3f)
+ * instead.
+ * @return the upward component of the acceleration (typically negative)
*/
@Deprecated
public float getGravity() {
return getGravity(null).y;
}
+ /**
+ * Copy this character's gravitational acceleration.
+ *
+ * @param out storage for the result (modified if not null)
+ * @return the acceleration vector (either the provided storage or a new
+ * vector, not null)
+ */
public Vector3f getGravity(Vector3f out) {
if(out==null)out=new Vector3f();
getGravity(characterId,out);
@@ -244,12 +334,24 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void getGravity(long characterId,Vector3f out);
+ /**
+ * Read this character's linear damping.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getLinearDamping(){
return getLinearDamping(characterId);
}
private native float getLinearDamping(long characterId);
+ /**
+ * Alter this character's linear damping.
+ *
+ * @param v the desired viscous damping ratio (0→no damping,
+ * 1→critically damped)
+ */
public void setLinearDamping(float v ){
setLinearDamping(characterId,v );
@@ -258,13 +360,24 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setLinearDamping(long characterId,float v);
+ /**
+ * Read this character's angular damping.
+ *
+ * @return the viscous damping ratio (0→no damping, 1→critically
+ * damped)
+ */
public float getAngularDamping(){
return getAngularDamping(characterId);
}
private native float getAngularDamping(long characterId);
-
+ /**
+ * Alter this character's angular damping.
+ *
+ * @param v the desired viscous damping ratio (0→no damping,
+ * 1→critically damped, default=0)
+ */
public void setAngularDamping(float v ){
setAngularDamping(characterId,v );
}
@@ -272,13 +385,22 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setAngularDamping(long characterId,float v);
+ /**
+ * Read this character's step height.
+ *
+ * @return the height (in physics-space units)
+ */
public float getStepHeight(){
return getStepHeight(characterId);
}
private native float getStepHeight(long characterId);
-
+ /**
+ * Alter this character's step height.
+ *
+ * @param v the desired height (in physics-space units)
+ */
public void setStepHeight(float v ){
setStepHeight(characterId,v );
}
@@ -286,13 +408,22 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void setStepHeight(long characterId,float v);
+ /**
+ * Read this character's maximum penetration depth.
+ *
+ * @return the depth (in physics-space units)
+ */
public float getMaxPenetrationDepth(){
return getMaxPenetrationDepth(characterId);
}
private native float getMaxPenetrationDepth(long characterId);
-
+ /**
+ * Alter this character's maximum penetration depth.
+ *
+ * @param v the desired depth (in physics-space units)
+ */
public void setMaxPenetrationDepth(float v ){
setMaxPenetrationDepth(characterId,v );
}
@@ -303,18 +434,49 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
+ /**
+ * Alter this character's maximum slope angle.
+ *
+ * @param slopeRadians the desired angle (in radians)
+ */
public void setMaxSlope(float slopeRadians) {
setMaxSlope(characterId, slopeRadians);
}
private native void setMaxSlope(long characterId, float slopeRadians);
+ /**
+ * Read this character's maximum slope angle.
+ *
+ * @return the angle (in radians)
+ */
public float getMaxSlope() {
return getMaxSlope(characterId);
}
private native float getMaxSlope(long characterId);
+ /**
+ * Enable/disable this character's contact response.
+ *
+ * @param responsive true to respond to contacts, false to ignore them
+ * (default=true)
+ */
+ public void setContactResponse(boolean responsive) {
+ int flags = getCollisionFlags(objectId);
+ if (responsive) {
+ flags &= ~CollisionFlag.NO_CONTACT_RESPONSE;
+ } else {
+ flags |= CollisionFlag.NO_CONTACT_RESPONSE;
+ }
+ setCollisionFlags(objectId, flags);
+ }
+
+ /**
+ * Test whether this character is on the ground.
+ *
+ * @return true if on the ground, otherwise false
+ */
public boolean onGround() {
return onGround(characterId);
}
@@ -330,12 +492,24 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
}
+ /**
+ * Jump in the specified direction.
+ *
+ * @param dir desired jump direction (not null, unaffected)
+ */
public void jump(Vector3f dir) {
jump(characterId,dir);
}
private native void jump(long characterId,Vector3f v);
+ /**
+ * Apply the specified CollisionShape to this character. Note that the
+ * character should not be in any physics space while changing shape; the
+ * character gets rebuilt on the physics side.
+ *
+ * @param collisionShape the shape to apply (not null, alias created)
+ */
@Override
public void setCollisionShape(CollisionShape collisionShape) {
// if (!(collisionShape.getObjectId() instanceof ConvexShape)) {
@@ -350,15 +524,21 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
}
/**
- * Set the physics location (same as warp())
- * @param location the location of the actual physics object
+ * Directly alter this character's location. (Same as
+ * {@link #warp(com.jme3.math.Vector3f)}).)
+ *
+ * @param location the desired location (not null, unaffected)
*/
public void setPhysicsLocation(Vector3f location) {
warp(location);
}
/**
- * @return the physicsLocation
+ * Copy the location of this character's center of mass.
+ *
+ * @param trans storage for the result (modified if not null)
+ * @return the location vector (either the provided storage or a new vector,
+ * not null)
*/
public Vector3f getPhysicsLocation(Vector3f trans) {
if (trans == null) {
@@ -371,36 +551,72 @@ public class PhysicsCharacter extends PhysicsCollisionObject {
private native void getPhysicsLocation(long objectId, Vector3f vec);
/**
- * @return the physicsLocation
+ * Copy the location of this character's center of mass.
+ *
+ * @return a new location vector (not null)
*/
public Vector3f getPhysicsLocation() {
return getPhysicsLocation(null);
}
+ /**
+ * Alter this character's continuous collision detection (CCD) swept sphere
+ * radius.
+ *
+ * @param radius (≥0, default=0)
+ */
public void setCcdSweptSphereRadius(float radius) {
setCcdSweptSphereRadius(objectId, radius);
}
private native void setCcdSweptSphereRadius(long objectId, float radius);
+ /**
+ * Alter the amount of motion required to activate continuous collision
+ * detection (CCD).
+ *
- * GhostObject can keep track of all objects that are overlapping.
- * By default, this overlap is based on the AABB.
- * This is useful for creating a character controller,
- * collision sensors/triggers, explosions etc.
+ * btGhostObject is a special btCollisionObject, useful for fast localized
+ * collision queries.
+ *
* @author normenhansen
*/
public class PhysicsGhostObject extends PhysicsCollisionObject {
@@ -61,9 +64,18 @@ public class PhysicsGhostObject extends PhysicsCollisionObject {
protected final Quaternion tmp_inverseWorldRotation = new Quaternion();
private List
- * This avoids the problem of fast objects moving through other objects, set to zero to disable (default)
- * @param threshold
+ * Alter the amount of motion required to activate continuous collision
+ * detection (CCD).
+ *
- * Set this after adding the node to the PhysicsSpace,
- * the PhysicsSpace assigns its current gravity to the physics node when its added.
- * @param gravity the gravity vector to set
+ * Alter this body's gravitational acceleration.
+ *
- * To apply an impulse, use applyImpulse, use applyContinuousForce to apply continuous force.
- * @param force the force
+ * Apply a force to the PhysicsRigidBody. Effective only if the next physics
+ * update steps the physics space.
+ *
- * To apply an impulse, use applyImpulse.
- *
- * @param force the force
+ * Apply a force to the PhysicsRigidBody. Effective only if the next physics
+ * update steps the physics space.
+ *
- * To apply an impulse, use applyImpulse.
- *
- * @param torque the torque
+ * Apply a force to the PhysicsRigidBody. Effective only if the next physics
+ * update steps the physics space.
+ *
- * For most vehicle simulations, it is recommended to use the simplified Bullet
- * vehicle model as provided in btRaycastVehicle. Instead of simulation each wheel
- * and chassis as separate rigid bodies, connected by constraints, it uses a simplified model.
- * This simplified model has many benefits, and is widely used in commercial driving games.
- * The entire vehicle is represented as a single rigidbody, the chassis.
- * The collision detection of the wheels is approximated by ray casts,
- * and the tire friction is a basic anisotropic friction model.
- *
+ * For arcade style vehicle simulations, it is recommended to use the simplified
+ * Bullet vehicle model as provided in btRaycastVehicle. Instead of simulation
+ * each wheel and chassis as separate rigid bodies, connected by constraints, it
+ * uses a simplified model. This simplified model has many benefits, and is
+ * widely used in commercial driving games.
+ *
- * The coefficient of friction between the tyre and the ground.
- * Should be about 0.8 for realistic cars, but can increased for better handling.
- * Set large (10000.0) for kart racers
- * @param frictionSlip the frictionSlip to set
+ * Alter the initial friction for new wheels. Effective only before adding
+ * wheels. After adding a wheel, use {@link #setFrictionSlip(int, float)}.
+ *
- * The maximum distance the suspension can be compressed (centimetres)
- * @param maxSuspensionTravelCm the maxSuspensionTravelCm to set
+ * Alter the initial maximum suspension travel distance for new wheels.
+ * Effective only before adding wheels. After adding a wheel, use
+ * {@link #setMaxSuspensionTravelCm(int, float)}.
+ *
+ * @param maxSuspensionTravelCm the desired maximum distance the suspension
+ * can be compressed (in centimeters, default=500)
*/
public void setMaxSuspensionTravelCm(float maxSuspensionTravelCm) {
tuning.maxSuspensionTravelCm = maxSuspensionTravelCm;
}
/**
- * The maximum distance the suspension can be compressed (centimetres)
- * @param wheel
- * @param maxSuspensionTravelCm
+ * Alter the maximum suspension travel distance for the indexed wheel.
+ *
+ * @param wheel the index of the wheel to modify (≥0)
+ * @param maxSuspensionTravelCm the desired maximum distance the suspension
+ * can be compressed (in centimeters)
*/
public void setMaxSuspensionTravelCm(int wheel, float maxSuspensionTravelCm) {
wheels.get(wheel).setMaxSuspensionTravelCm(maxSuspensionTravelCm);
}
+ /**
+ * Read the initial maximum suspension force for new wheels.
+ *
+ * @return the maximum force per wheel
+ */
public float getMaxSuspensionForce() {
return tuning.maxSuspensionForce;
}
/**
- * This vaue caps the maximum suspension force, raise this above the default 6000 if your suspension cannot
- * handle the weight of your vehcile.
- * @param maxSuspensionForce
+ * Alter the initial maximum suspension force for new wheels. Effective only
+ * before adding wheels. After adding a wheel, use
+ * {@link #setMaxSuspensionForce(int, float)}.
+ *
- * The damping coefficient for when the suspension is compressed.
- * Set to k * 2.0 * FastMath.sqrt(m_suspensionStiffness) so k is proportional to critical damping.
- * k = 0.0 undamped & bouncy, k = 1.0 critical damping
- * 0.1 to 0.3 are good values
- * @param suspensionCompression the suspensionCompression to set
+ * Alter the initial damping (when the suspension is compressed) for new
+ * wheels. Effective only before adding wheels. After adding a wheel, use
+ * {@link #setSuspensionCompression(int, float)}.
+ *
- * k = 0.0 undamped & bouncy, k = 1.0 critical damping
- * 0.1 to 0.3 are good values
- * @param wheel
- * @param suspensionCompression
+ * Alter the damping (when the suspension is compressed) for the indexed
+ * wheel.
+ *
- * The damping coefficient for when the suspension is expanding.
- * See the comments for setSuspensionCompression for how to set k.
- * @param suspensionDamping the suspensionDamping to set
+ * Alter the initial damping (when the suspension is expanded) for new
+ * wheels. Effective only before adding wheels. After adding a wheel, use
+ * {@link #setSuspensionCompression(int, float)}.
+ *
- * The stiffness constant for the suspension. 10.0 - Offroad buggy, 50.0 - Sports car, 200.0 - F1 Car
- * @param suspensionStiffness
+ * Alter the initial suspension stiffness for new wheels. Effective only
+ * before adding wheels. After adding a wheel, use
+ * {@link #setSuspensionStiffness(int, float)}.
+ *
+ * @param suspensionStiffness the desired stiffness coefficient
+ * (10→off-road buggy, 50→sports car, 200→Formula-1 race car,
+ * default=5.88)
*/
public void setSuspensionStiffness(float suspensionStiffness) {
tuning.suspensionStiffness = suspensionStiffness;
}
/**
- * The stiffness constant for the suspension. 10.0 - Offroad buggy, 50.0 - Sports car, 200.0 - F1 Car
- * @param wheel
- * @param suspensionStiffness
+ * Alter the suspension stiffness of the indexed wheel.
+ *
+ * @param wheel the index of the wheel to modify (≥0)
+ * @param suspensionStiffness the desired stiffness coefficient
+ * (10→off-road buggy, 50→sports car, 200→Formula-1 race car,
+ * default=5.88)
*/
public void setSuspensionStiffness(int wheel, float suspensionStiffness) {
wheels.get(wheel).setSuspensionStiffness(suspensionStiffness);
}
/**
- * Reset the suspension
+ * Reset this vehicle's suspension.
*/
public void resetSuspension() {
resetSuspension(vehicleId);
@@ -397,8 +528,9 @@ public class PhysicsVehicle extends PhysicsRigidBody {
private native void resetSuspension(long vehicleId);
/**
- * Apply the given engine force to all wheels, works continuously
- * @param force the force
+ * Apply the specified engine force to all wheels. Works continuously.
+ *
+ * @param force the desired amount of force
*/
public void accelerate(float force) {
for (int i = 0; i < wheels.size(); i++) {
@@ -407,9 +539,10 @@ public class PhysicsVehicle extends PhysicsRigidBody {
}
/**
- * Apply the given engine force, works continuously
- * @param wheel the wheel to apply the force on
- * @param force the force
+ * Apply the given engine force to the indexed wheel. Works continuously.
+ *
+ * @param wheel the index of the wheel to apply the force to (≥0)
+ * @param force the desired amount of force
*/
public void accelerate(int wheel, float force) {
applyEngineForce(vehicleId, wheel, force);
@@ -419,8 +552,9 @@ public class PhysicsVehicle extends PhysicsRigidBody {
private native void applyEngineForce(long vehicleId, int wheel, float force);
/**
- * Set the given steering value to all front wheels (0 = forward)
- * @param value the steering angle of the front wheels (Pi = 360deg)
+ * Alter the steering angle of all front wheels.
+ *
+ * @param value the desired steering angle (in radians, 0=straight)
*/
public void steer(float value) {
for (int i = 0; i < wheels.size(); i++) {
@@ -431,9 +565,10 @@ public class PhysicsVehicle extends PhysicsRigidBody {
}
/**
- * Set the given steering value to the given wheel (0 = forward)
- * @param wheel the wheel to set the steering on
- * @param value the steering angle of the front wheels (Pi = 360deg)
+ * Alter the steering angle of the indexed wheel.
+ *
+ * @param wheel the index of the wheel to steer (≥0)
+ * @param value the desired steering angle (in radians, 0=straight)
*/
public void steer(int wheel, float value) {
steer(vehicleId, wheel, value);
@@ -442,8 +577,9 @@ public class PhysicsVehicle extends PhysicsRigidBody {
private native void steer(long vehicleId, int wheel, float value);
/**
- * Apply the given brake force to all wheels, works continuously
- * @param force the force
+ * Apply the given brake force to all wheels. Works continuously.
+ *
+ * @param force the desired amount of force
*/
public void brake(float force) {
for (int i = 0; i < wheels.size(); i++) {
@@ -452,9 +588,10 @@ public class PhysicsVehicle extends PhysicsRigidBody {
}
/**
- * Apply the given brake force, works continuously
- * @param wheel the wheel to apply the force on
- * @param force the force
+ * Apply the given brake force to the indexed wheel. Works continuously.
+ *
+ * @param wheel the index of the wheel to apply the force to (≥0)
+ * @param force the desired amount of force
*/
public void brake(int wheel, float force) {
brake(vehicleId, wheel, force);
@@ -463,8 +600,9 @@ public class PhysicsVehicle extends PhysicsRigidBody {
private native void brake(long vehicleId, int wheel, float force);
/**
- * Get the current speed of the vehicle in km/h
- * @return
+ * Read the vehicle's speed in km/h.
+ *
+ * @return speed (in kilometers per hour)
*/
public float getCurrentVehicleSpeedKmHour() {
return getCurrentVehicleSpeedKmHour(vehicleId);
@@ -473,9 +611,11 @@ public class PhysicsVehicle extends PhysicsRigidBody {
private native float getCurrentVehicleSpeedKmHour(long vehicleId);
/**
- * Get the current forward vector of the vehicle in world coordinates
- * @param vector
- * @return
+ * Copy the vehicle's forward direction.
+ *
+ * @param vector storage for the result (modified if not null)
+ * @return a direction vector (in physics-space coordinates, either the
+ * provided storage or a new vector, not null)
*/
public Vector3f getForwardVector(Vector3f vector) {
if (vector == null) {
@@ -489,11 +629,19 @@ public class PhysicsVehicle extends PhysicsRigidBody {
/**
* used internally
+ *
+ * @return the unique identifier
*/
public long getVehicleId() {
return vehicleId;
}
+ /**
+ * De-serialize this vehicle, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
InputCapsule capsule = im.getCapsule(this);
@@ -509,6 +657,12 @@ public class PhysicsVehicle extends PhysicsRigidBody {
super.read(im);
}
+ /**
+ * Serialize this vehicle, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
OutputCapsule capsule = ex.getCapsule(this);
@@ -522,6 +676,12 @@ public class PhysicsVehicle extends PhysicsRigidBody {
super.write(ex);
}
+ /**
+ * Finalize this vehicle just before it is destroyed. Should be invoked only
+ * by a subclass or by the garbage collector.
+ *
+ * @throws Throwable ignored by the garbage collector
+ */
@Override
protected void finalize() throws Throwable {
super.finalize();
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/objects/VehicleWheel.java b/jme3-bullet/src/main/java/com/jme3/bullet/objects/VehicleWheel.java
index 1e86cc256..25fa2c103 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/objects/VehicleWheel.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/objects/VehicleWheel.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -40,42 +40,142 @@ import com.jme3.scene.Spatial;
import java.io.IOException;
/**
- * Stores info about one wheel of a PhysicsVehicle
+ * Information about one wheel of a PhysicsVehicle.
+ *
* @author normenhansen
*/
public class VehicleWheel implements Savable {
+ /**
+ * unique identifier of the btRaycastVehicle
+ */
protected long wheelId = 0;
+ /**
+ * 0-origin index among the vehicle's wheels (≥0)
+ */
protected int wheelIndex = 0;
+ /**
+ * copy of wheel type: true→front (steering) wheel,
+ * false→non-front wheel
+ */
protected boolean frontWheel;
+ /**
+ * location where the suspension connects to the chassis (in chassis
+ * coordinates)
+ */
protected Vector3f location = new Vector3f();
+ /**
+ * suspension direction (in chassis coordinates, typically down/0,-1,0)
+ */
protected Vector3f direction = new Vector3f();
+ /**
+ * axis direction (in chassis coordinates, typically to the right/-1,0,0)
+ */
protected Vector3f axle = new Vector3f();
+ /**
+ * copy of suspension stiffness constant (10→off-road buggy,
+ * 50→sports car, 200→Formula-1 race car, default=20)
+ */
protected float suspensionStiffness = 20.0f;
+ /**
+ * copy of suspension damping when expanded (0→no damping, default=2.3)
+ */
protected float wheelsDampingRelaxation = 2.3f;
+ /**
+ * copy of suspension damping when compressed (0→no damping,
+ * default=4.4)
+ */
protected float wheelsDampingCompression = 4.4f;
+ /**
+ * copy of coefficient of friction between tyre and ground
+ * (0.8→realistic car, 10000→kart racer, default=10.5)
+ */
protected float frictionSlip = 10.5f;
+ /**
+ * copy of roll-influence factor (0→no roll torque, 1→realistic
+ * behavior, default=1)
+ */
protected float rollInfluence = 1.0f;
+ /**
+ * copy of maximum suspension travel distance (in centimeters, default=500)
+ */
protected float maxSuspensionTravelCm = 500f;
+ /**
+ * copy of maximum force exerted by the suspension (default=6000)
+ */
protected float maxSuspensionForce = 6000f;
+ /**
+ * copy of wheel radius (in physics-space units, >0)
+ */
protected float radius = 0.5f;
+ /**
+ * copy of rest length of the suspension (in physics-space units)
+ */
protected float restLength = 1f;
+ /**
+ * wheel location in physics-space coordinates
+ */
protected Vector3f wheelWorldLocation = new Vector3f();
+ /**
+ * wheel orientation in physics-space coordinates
+ */
protected Quaternion wheelWorldRotation = new Quaternion();
+ /**
+ * associated spatial, or null if none
+ */
protected Spatial wheelSpatial;
protected Matrix3f tmp_Matrix = new com.jme3.math.Matrix3f();
protected final Quaternion tmp_inverseWorldRotation = new Quaternion();
+ /**
+ * true → physics coordinates match local transform, false →
+ * physics coordinates match world transform
+ */
private boolean applyLocal = false;
+ /**
+ * No-argument constructor needed by SavableClassUtil. Do not invoke
+ * directly!
+ */
public VehicleWheel() {
}
+ /**
+ * Instantiate a wheel.
+ *
+ * @param spat the associated spatial, or null if none
+ * @param location the location where the suspension connects to the chassis
+ * (in chassis coordinates, not null, unaffected)
+ * @param direction the suspension direction (in chassis coordinates, not
+ * null, unaffected, typically down/0,-1,0)
+ * @param axle the axis direction (in chassis coordinates, not null,
+ * unaffected, typically right/-1,0,0)
+ * @param restLength the rest length of the suspension (in physics-space
+ * units)
+ * @param radius the wheel's radius (in physics-space units, ≥0)
+ * @param frontWheel true→front (steering) wheel, false→non-front
+ * wheel
+ */
public VehicleWheel(Spatial spat, Vector3f location, Vector3f direction, Vector3f axle,
float restLength, float radius, boolean frontWheel) {
this(location, direction, axle, restLength, radius, frontWheel);
wheelSpatial = spat;
}
+ /**
+ * Instantiate a wheel without an associated spatial.
+ *
+ * @param location the location where the suspension connects to the chassis
+ * (in chassis coordinates, not null, unaffected)
+ * @param direction the suspension direction (in chassis coordinates, not
+ * null, unaffected, typically down/0,-1,0)
+ * @param axle the axis direction (in chassis coordinates, not null,
+ * unaffected, typically right/-1,0,0)
+ * @param restLength the rest length of the suspension (in physics-space
+ * units)
+ * @param radius the wheel's radius (in physics-space units, ≥0)
+ * @param frontWheel true→front (steering) wheel, false→non-front
+ * wheel
+ */
public VehicleWheel(Vector3f location, Vector3f direction, Vector3f axle,
float restLength, float radius, boolean frontWheel) {
this.location.set(location);
@@ -86,6 +186,9 @@ public class VehicleWheel implements Savable {
this.radius = radius;
}
+ /**
+ * Update this wheel's location and orientation in physics space.
+ */
public void updatePhysicsState() {
getWheelLocation(wheelId, wheelIndex, wheelWorldLocation);
getWheelRotation(wheelId, wheelIndex, tmp_Matrix);
@@ -96,6 +199,10 @@ public class VehicleWheel implements Savable {
private native void getWheelRotation(long vehicleId, int wheelId, Matrix3f location);
+ /**
+ * Apply this wheel's physics location and orientation to its associated
+ * spatial, if any.
+ */
public void applyWheelTransform() {
if (wheelSpatial == null) {
return;
@@ -118,132 +225,232 @@ public class VehicleWheel implements Savable {
}
}
+ /**
+ * Read the id of the btRaycastVehicle.
+ *
+ * @return the unique identifier (not zero)
+ */
public long getWheelId() {
return wheelId;
}
+ /**
+ * Assign this wheel to a vehicle.
+ *
+ * @param vehicleId the id of the btRaycastVehicle (not zero)
+ * @param wheelIndex index among the vehicle's wheels (≥0)
+ */
public void setVehicleId(long vehicleId, int wheelIndex) {
this.wheelId = vehicleId;
this.wheelIndex = wheelIndex;
applyInfo();
}
+ /**
+ * Test whether this wheel is a front wheel.
+ *
+ * @return true if front wheel, otherwise false
+ */
public boolean isFrontWheel() {
return frontWheel;
}
+ /**
+ * Alter whether this wheel is a front (steering) wheel.
+ *
+ * @param frontWheel true→front wheel, false→non-front wheel
+ */
public void setFrontWheel(boolean frontWheel) {
this.frontWheel = frontWheel;
applyInfo();
}
+ /**
+ * Access the location where the suspension connects to the chassis.
+ *
+ * @return the pre-existing location vector (in chassis coordinates, not
+ * null)
+ */
public Vector3f getLocation() {
return location;
}
+ /**
+ * Access this wheel's suspension direction.
+ *
+ * @return the pre-existing direction vector (in chassis coordinates, not
+ * null)
+ */
public Vector3f getDirection() {
return direction;
}
+ /**
+ * Access this wheel's axle direction.
+ *
+ * @return the pre-existing direction vector (not null)
+ */
public Vector3f getAxle() {
return axle;
}
+ /**
+ * Read the stiffness constant for this wheel's suspension.
+ *
+ * @return the stiffness constant
+ */
public float getSuspensionStiffness() {
return suspensionStiffness;
}
/**
- * the stiffness constant for the suspension. 10.0 - Offroad buggy, 50.0 - Sports car, 200.0 - F1 Car
- * @param suspensionStiffness
+ * Alter the stiffness constant for this wheel's suspension.
+ *
+ * @param suspensionStiffness the desired stiffness constant
+ * (10→off-road buggy, 50→sports car, 200→Formula-1 race car,
+ * default=20)
*/
public void setSuspensionStiffness(float suspensionStiffness) {
this.suspensionStiffness = suspensionStiffness;
applyInfo();
}
+ /**
+ * Read this wheel's damping when the suspension is expanded.
+ *
+ * @return the damping
+ */
public float getWheelsDampingRelaxation() {
return wheelsDampingRelaxation;
}
/**
- * the damping coefficient for when the suspension is expanding.
- * See the comments for setWheelsDampingCompression for how to set k.
- * @param wheelsDampingRelaxation
+ * Alter this wheel's damping when the suspension is expanded.
+ *
- * k = 0.0 undamped & bouncy, k = 1.0 critical damping
- * 0.1 to 0.3 are good values
- * @param wheelsDampingCompression
+ * Alter this wheel's damping when the suspension is compressed.
+ *
- * 0.0 = wheels are sliding, 1.0 = wheels have traction.
+ * Calculate to what extent the wheel is skidding (for skid sounds/smoke
+ * etc.)
+ *
+ * @return the relative amount of traction (0→wheel is sliding,
+ * 1→wheel has full traction)
*/
public float getSkidInfo() {
return getSkidInfo(wheelId, wheelIndex);
@@ -351,8 +592,9 @@ public class VehicleWheel implements Savable {
public native float getSkidInfo(long wheelId, int wheelIndex);
/**
- * returns how many degrees the wheel has turned since the last physics
- * step.
+ * Calculate how much this wheel has turned since the last physics step.
+ *
+ * @return the rotation angle (in radians)
*/
public float getDeltaRotation() {
return getDeltaRotation(wheelId, wheelIndex);
@@ -360,6 +602,12 @@ public class VehicleWheel implements Savable {
public native float getDeltaRotation(long wheelId, int wheelIndex);
+ /**
+ * De-serialize this wheel, for example when loading from a J3O file.
+ *
+ * @param im importer (not null)
+ * @throws IOException from importer
+ */
@Override
public void read(JmeImporter im) throws IOException {
InputCapsule capsule = im.getCapsule(this);
@@ -379,6 +627,12 @@ public class VehicleWheel implements Savable {
restLength = capsule.readFloat("restLength", 1f);
}
+ /**
+ * Serialize this wheel, for example when saving to a J3O file.
+ *
+ * @param ex exporter (not null)
+ * @throws IOException from exporter
+ */
@Override
public void write(JmeExporter ex) throws IOException {
OutputCapsule capsule = ex.getCapsule(this);
@@ -399,41 +653,59 @@ public class VehicleWheel implements Savable {
}
/**
- * @return the wheelSpatial
+ * Access the spatial associated with this wheel.
+ *
+ * @return the pre-existing instance, or null
*/
public Spatial getWheelSpatial() {
return wheelSpatial;
}
/**
- * @param wheelSpatial the wheelSpatial to set
+ * Alter which spatial is associated with this wheel.
+ *
+ * @param wheelSpatial the desired spatial, or null for none
*/
public void setWheelSpatial(Spatial wheelSpatial) {
this.wheelSpatial = wheelSpatial;
}
+ /**
+ * Test whether physics coordinates should match the local transform of the
+ * Spatial.
+ *
+ * @return true if matching local transform, false if matching world
+ * transform
+ */
public boolean isApplyLocal() {
return applyLocal;
}
+ /**
+ * Alter whether physics coordinates should match the local transform of the
+ * Spatial.
+ *
+ * @param applyLocal true→match local transform, false→match world
+ * transform (default=false)
+ */
public void setApplyLocal(boolean applyLocal) {
this.applyLocal = applyLocal;
}
/**
- * write the content of the wheelWorldRotation into the store
- *
- * @param store
- */
+ * Copy this wheel's physics-space orientation to the specified quaternion.
+ *
+ * @param store storage for the result (not null, modified)
+ */
public void getWheelWorldRotation(final Quaternion store) {
store.set(this.wheelWorldRotation);
}
/**
- * write the content of the wheelWorldLocation into the store
- *
- * @param store
- */
+ * Copy this wheel's physics-space location to the specified vector.
+ *
+ * @param store storage for the result (not null, modified)
+ */
public void getWheelWorldLocation(final Vector3f store) {
store.set(this.wheelWorldLocation);
}
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/objects/infos/RigidBodyMotionState.java b/jme3-bullet/src/main/java/com/jme3/bullet/objects/infos/RigidBodyMotionState.java
index 3406e7ae5..bee3bf78d 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/objects/infos/RigidBodyMotionState.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/objects/infos/RigidBodyMotionState.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -40,8 +40,8 @@ import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * stores transform info of a PhysicsNode in a threadsafe manner to
- * allow multithreaded access from the jme scenegraph and the bullet physicsspace
+ * The motion state (transform) of a rigid body, with thread-safe access.
+ *
* @author normenhansen
*/
public class RigidBodyMotionState {
@@ -51,9 +51,16 @@ public class RigidBodyMotionState {
private Quaternion worldRotationQuat = new Quaternion();
private Quaternion tmp_inverseWorldRotation = new Quaternion();
private PhysicsVehicle vehicle;
+ /**
+ * true → physics coordinates match local transform, false →
+ * physics coordinates match world transform
+ */
private boolean applyPhysicsLocal = false;
// protected LinkedList
- * To attach a debug shape to a physics object, call attachDebugShape(AssetManager manager);
on it.
- * @param collisionShape
- * @return
+ * Create a debug spatial from the specified collision shape.
+ * attachDebugShape(AssetManager manager);
on it.
+ *
+ * @param collisionShape the shape to visualize (may be null, unaffected)
+ * @return a new tree of geometries, or null
*/
public static Spatial getDebugShape(CollisionShape collisionShape) {
if (collisionShape == null) {
@@ -101,6 +105,12 @@ public class DebugShapeFactory {
return debugShape;
}
+ /**
+ * Create a geometry for visualizing the specified shape.
+ *
+ * @param shape (not null, unaffected)
+ * @return a new geometry (not null)
+ */
private static Geometry createDebugShape(CollisionShape shape) {
Geometry geom = new Geometry();
geom.setMesh(DebugShapeFactory.getDebugMesh(shape));
@@ -109,11 +119,18 @@ public class DebugShapeFactory {
return geom;
}
+ /**
+ * Create a mesh for visualizing the specified shape.
+ *
+ * @param shape (not null, unaffected)
+ * @return a new mesh (not null)
+ */
public static Mesh getDebugMesh(CollisionShape shape) {
Mesh mesh = new Mesh();
- mesh = new Mesh();
DebugMeshCallback callback = new DebugMeshCallback();
- getVertices(shape.getObjectId(), callback);
+ long id = shape.getObjectId();
+ getVertices(id, callback);
+
mesh.setBuffer(Type.Position, 3, callback.getVertices());
mesh.getFloatBuffer(Type.Position).clear();
return mesh;
diff --git a/jme3-bullet/src/main/java/com/jme3/bullet/util/NativeMeshUtil.java b/jme3-bullet/src/main/java/com/jme3/bullet/util/NativeMeshUtil.java
index fc3ad53d6..caf172c82 100644
--- a/jme3-bullet/src/main/java/com/jme3/bullet/util/NativeMeshUtil.java
+++ b/jme3-bullet/src/main/java/com/jme3/bullet/util/NativeMeshUtil.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -39,18 +39,26 @@ import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
/**
+ * A utility class for interfacing with Native Bullet.
*
* @author normenhansen
*/
public class NativeMeshUtil {
+ /**
+ * Pass a mesh to Native Bullet.
+ *
+ * @param mesh the JME mesh to pass (not null)
+ * @return the unique identifier of the resulting btTriangleIndexVertexArray
+ * (not 0)
+ */
public static long getTriangleIndexVertexArray(Mesh mesh){
ByteBuffer triangleIndexBase = BufferUtils.createByteBuffer(mesh.getTriangleCount() * 3 * 4);
ByteBuffer vertexBase = BufferUtils.createByteBuffer(mesh.getVertexCount() * 3 * 4);
int numVertices = mesh.getVertexCount();
- int vertexStride = 12; //3 verts * 4 bytes per.
+ int vertexStride = 12; //3 verts * 4 bytes each
int numTriangles = mesh.getTriangleCount();
- int triangleIndexStride = 12; //3 index entries * 4 bytes each.
+ int triangleIndexStride = 12; //3 index entries * 4 bytes each
IndexBuffer indices = mesh.getIndicesAsList();
FloatBuffer vertices = mesh.getFloatBuffer(Type.Position);
@@ -72,6 +80,18 @@ public class NativeMeshUtil {
return createTriangleIndexVertexArray(triangleIndexBase, vertexBase, numTriangles, numVertices, vertexStride, triangleIndexStride);
}
+ /**
+ * Instantiate a btTriangleIndexVertexArray. Native method.
+ *
+ * @param triangleIndexBase index buffer (not null)
+ * @param vertexBase vertex buffer (not null)
+ * @param numTraingles the number of triangles in the mesh (≥0)
+ * @param numVertices the number of vertices in the mesh (≥0)
+ * @param vertextStride (in bytes, >0)
+ * @param triangleIndexStride (in bytes, >0)
+ * @return the unique identifier of the resulting btTriangleIndexVertexArray
+ * (not 0)
+ */
public static native long createTriangleIndexVertexArray(ByteBuffer triangleIndexBase, ByteBuffer vertexBase, int numTraingles, int numVertices, int vertextStride, int triangleIndexStride);
}
diff --git a/jme3-core/src/main/java/checkers/quals/DefaultQualifiers.java b/jme3-core/src/main/java/checkers/quals/DefaultQualifiers.java
index e483e63e7..42854ee43 100644
--- a/jme3-core/src/main/java/checkers/quals/DefaultQualifiers.java
+++ b/jme3-core/src/main/java/checkers/quals/DefaultQualifiers.java
@@ -15,7 +15,7 @@ import java.lang.annotation.Target;
* annotations of the same name at a single location.
*
* Example:
- *
+ *
*
* @DefaultQualifiers({
* @DefaultQualifier("NonNull"),
diff --git a/jme3-core/src/main/java/com/jme3/anim/AnimClip.java b/jme3-core/src/main/java/com/jme3/anim/AnimClip.java
new file mode 100644
index 000000000..9b86858a3
--- /dev/null
+++ b/jme3-core/src/main/java/com/jme3/anim/AnimClip.java
@@ -0,0 +1,99 @@
+package com.jme3.anim;
+
+import com.jme3.anim.tween.Tween;
+import com.jme3.export.*;
+import com.jme3.util.SafeArrayList;
+import com.jme3.util.clone.Cloner;
+import com.jme3.util.clone.JmeCloneable;
+
+import java.io.IOException;
+
+/**
+ * Created by Nehon on 20/12/2017.
+ */
+public class AnimClip implements JmeCloneable, Savable {
+
+ private String name;
+ private double length;
+
+ private AnimTrack[] tracks;
+
+ public AnimClip() {
+ }
+
+ public AnimClip(String name) {
+ this.name = name;
+ }
+
+ public void setTracks(AnimTrack[] tracks) {
+ this.tracks = tracks;
+ for (AnimTrack track : tracks) {
+ if (track.getLength() > length) {
+ length = track.getLength();
+ }
+ }
+ }
+
+ public String getName() {
+ return name;
+ }
+
+
+ public double getLength() {
+ return length;
+ }
+
+
+ public AnimTrack[] getTracks() {
+ return tracks;
+ }
+
+ @Override
+ public Object jmeClone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new RuntimeException("Error cloning", e);
+ }
+ }
+
+ @Override
+ public void cloneFields(Cloner cloner, Object original) {
+ AnimTrack[] newTracks = new AnimTrack[tracks.length];
+ for (int i = 0; i < tracks.length; i++) {
+ newTracks[i] = (cloner.clone(tracks[i]));
+ }
+ this.tracks = newTracks;
+ }
+
+ @Override
+ public String toString() {
+ return "Clip " + name + ", " + length + 's';
+ }
+
+ @Override
+ public void write(JmeExporter ex) throws IOException {
+ OutputCapsule oc = ex.getCapsule(this);
+ oc.write(name, "name", null);
+ oc.write(tracks, "tracks", null);
+
+ }
+
+ @Override
+ public void read(JmeImporter im) throws IOException {
+ InputCapsule ic = im.getCapsule(this);
+ name = ic.readString("name", null);
+ Savable[] arr = ic.readSavableArray("tracks", null);
+ if (arr != null) {
+ tracks = new AnimTrack[arr.length];
+ for (int i = 0; i < arr.length; i++) {
+ AnimTrack t = (AnimTrack) arr[i];
+ tracks[i] = t;
+ if (t.getLength() > length) {
+ length = t.getLength();
+ }
+ }
+ }
+ }
+
+}
diff --git a/jme3-core/src/main/java/com/jme3/anim/AnimComposer.java b/jme3-core/src/main/java/com/jme3/anim/AnimComposer.java
new file mode 100644
index 000000000..646289367
--- /dev/null
+++ b/jme3-core/src/main/java/com/jme3/anim/AnimComposer.java
@@ -0,0 +1,250 @@
+package com.jme3.anim;
+
+import com.jme3.anim.tween.Tween;
+import com.jme3.anim.tween.Tweens;
+import com.jme3.anim.tween.action.*;
+import com.jme3.export.*;
+import com.jme3.renderer.RenderManager;
+import com.jme3.renderer.ViewPort;
+import com.jme3.scene.control.AbstractControl;
+import com.jme3.util.clone.Cloner;
+import com.jme3.util.clone.JmeCloneable;
+
+import java.io.IOException;
+import java.util.*;
+
+/**
+ * Created by Nehon on 20/12/2017.
+ */
+public class AnimComposer extends AbstractControl {
+
+ public static final String DEFAULT_LAYER = "Default";
+ private Map
AnimControl
.
+ *
+ * @param anim The animation to add.
+ */
+ public void addAnimClip(AnimClip anim) {
+ animClipMap.put(anim.getName(), anim);
+ }
+
+ /**
+ * Remove an animation so that it is no longer available for playing.
+ *
+ * @param anim The animation to remove.
+ */
+ public void removeAnimClip(AnimClip anim) {
+ if (!animClipMap.containsKey(anim.getName())) {
+ throw new IllegalArgumentException("Given animation does not exist "
+ + "in this AnimControl");
+ }
+
+ animClipMap.remove(anim.getName());
+ }
+
+ public Action setCurrentAction(String name) {
+ return setCurrentAction(name, DEFAULT_LAYER);
+ }
+
+ public Action setCurrentAction(String actionName, String layerName) {
+ Layer l = layers.get(layerName);
+ if (l == null) {
+ throw new IllegalArgumentException("Unknown layer " + layerName);
+ }
+ Action currentAction = action(actionName);
+ l.time = 0;
+ l.currentAction = currentAction;
+ return currentAction;
+ }
+
+ public Action action(String name) {
+ Action action = actions.get(name);
+ if (action == null) {
+ action = makeAction(name);
+ actions.put(name, action);
+ }
+ return action;
+ }
+
+ public Action makeAction(String name) {
+ Action action;
+ AnimClip clip = animClipMap.get(name);
+ if (clip == null) {
+ throw new IllegalArgumentException("Cannot find clip named " + name);
+ }
+ action = new ClipAction(clip);
+ return action;
+ }
+
+ public void makeLayer(String name, AnimationMask mask){
+ Layer l = new Layer();
+ l.mask = mask;
+ layers.put(name, l);
+ }
+
+
+ public BaseAction actionSequence(String name, Tween... tweens) {
+ BaseAction action = new BaseAction(Tweens.sequence(tweens));
+ actions.put(name, action);
+ return action;
+ }
+
+ public BlendAction actionBlended(String name, BlendSpace blendSpace, String... clips) {
+ BlendableAction[] acts = new BlendableAction[clips.length];
+ for (int i = 0; i < acts.length; i++) {
+ BlendableAction ba = (BlendableAction) makeAction(clips[i]);
+ acts[i] = ba;
+ }
+ BlendAction action = new BlendAction(blendSpace, acts);
+ actions.put(name, action);
+ return action;
+ }
+
+ public void reset() {
+ for (Layer layer : layers.values()) {
+ layer.currentAction = null;
+ layer.time = 0;
+ }
+ }
+
+ public CollectionTweens.callTweenMethod(1, myObject, "foo", "bar")
+ *
+ * void foo( float t, String arg )
+ * void foo( double t, String arg )
+ * void foo( String arg, float t )
+ * void foo( String arg, double t )
+ *
+ */
+ public static Tween callTweenMethod(double length, Object target, String method, Object... args) {
+ return new CallTweenMethod(length, target, method, args);
+ }
+
+ private static interface CurveFunction {
+ public double curve(double input);
+ }
+
+ /**
+ * Curve function for Hermite interpolation ala GLSL smoothstep().
+ */
+ private static class SmoothStep implements CurveFunction {
+
+ @Override
+ public double curve(double t) {
+ if (t < 0) {
+ return 0;
+ } else if (t > 1) {
+ return 1;
+ }
+ return t * t * (3 - 2 * t);
+ }
+ }
+
+ private static class Sine implements CurveFunction {
+
+ @Override
+ public double curve(double t) {
+ if (t < 0) {
+ return 0;
+ } else if (t > 1) {
+ return 1;
+ }
+ // Sine starting at -90 will go from -1 to 1 through 0
+ double result = Math.sin(t * Math.PI - Math.PI * 0.5);
+ return (result + 1) * 0.5;
+ }
+ }
+
+ private static class Curve implements Tween {
+ private final Tween delegate;
+ private final CurveFunction func;
+ private final double length;
+
+ public Curve(Tween delegate, CurveFunction func) {
+ this.delegate = delegate;
+ this.func = func;
+ this.length = delegate.getLength();
+ }
+
+ @Override
+ public double getLength() {
+ return length;
+ }
+
+ @Override
+ public boolean interpolate(double t) {
+ // Sanity check the inputs
+ if (t < 0) {
+ return true;
+ }
+
+ if (length == 0) {
+ // Caller did something strange but we'll allow it
+ return delegate.interpolate(t);
+ }
+
+ t = func.curve(t / length);
+ return delegate.interpolate(t * length);
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[delegate=" + delegate + ", func=" + func + "]";
+ }
+ }
+
+ private static class Sequence implements Tween, ContainsTweens {
+ private final Tween[] delegates;
+ private int current = 0;
+ private double baseTime;
+ private double length;
+
+ public Sequence(Tween... delegates) {
+ this.delegates = delegates;
+ for (Tween t : delegates) {
+ length += t.getLength();
+ }
+ }
+
+ @Override
+ public double getLength() {
+ return length;
+ }
+
+ @Override
+ public boolean interpolate(double t) {
+
+ // Sanity check the inputs
+ if (t < 0) {
+ return true;
+ }
+
+ if (t < baseTime) {
+ // We've rolled back before the current sequence step
+ // which means we need to reset and start forward
+ // again. We have no idea how to 'roll back' and
+ // this is the only way to maintain consistency.
+ // The only 'normal' case where this happens is when looping
+ // in which case a full rollback is appropriate.
+ current = 0;
+ baseTime = 0;
+ }
+
+ if (current >= delegates.length) {
+ return false;
+ }
+
+ // Skip any that are done
+ while (!delegates[current].interpolate(t - baseTime)) {
+ // Time to go to the next one
+ baseTime += delegates[current].getLength();
+ current++;
+ if (current >= delegates.length) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[delegates=" + Arrays.asList(delegates) + "]";
+ }
+
+ @Override
+ public Tween[] getTweens() {
+ return delegates;
+ }
+ }
+
+ private static class Parallel implements Tween, ContainsTweens {
+ private final Tween[] delegates;
+ private final boolean[] done;
+ private double length;
+ private double lastTime;
+
+ public Parallel(Tween... delegates) {
+ this.delegates = delegates;
+ done = new boolean[delegates.length];
+
+ for (Tween t : delegates) {
+ if (t.getLength() > length) {
+ length = t.getLength();
+ }
+ }
+ }
+
+ @Override
+ public double getLength() {
+ return length;
+ }
+
+ protected void reset() {
+ for (int i = 0; i < done.length; i++) {
+ done[i] = false;
+ }
+ }
+
+ @Override
+ public boolean interpolate(double t) {
+ // Sanity check the inputs
+ if (t < 0) {
+ return true;
+ }
+
+ if (t < lastTime) {
+ // We've rolled back before the last time we were given.
+ // This means we may have 'done'ed a few tasks that now
+ // need to be run again. Better to just reset and start
+ // over. As mentioned in the Sequence task, the only 'normal'
+ // use-case for time rolling backwards is when looping. And
+ // in that case, we want to start from the beginning anyway.
+ reset();
+ }
+ lastTime = t;
+
+ int runningCount = delegates.length;
+ for (int i = 0; i < delegates.length; i++) {
+ if (!done[i]) {
+ done[i] = !delegates[i].interpolate(t);
+ }
+ if (done[i]) {
+ runningCount--;
+ }
+ }
+ return runningCount > 0;
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[delegates=" + Arrays.asList(delegates) + "]";
+ }
+
+ @Override
+ public Tween[] getTweens() {
+ return delegates;
+ }
+ }
+
+ private static class Delay extends AbstractTween {
+
+ public Delay(double length) {
+ super(length);
+ }
+
+ @Override
+ protected void doInterpolate(double t) {
+ }
+ }
+
+ private static class Stretch implements Tween, ContainsTweens {
+
+ private final Tween[] delegate = new Tween[1];
+ private final double length;
+ private final double scale;
+
+ public Stretch(Tween delegate, double length) {
+ this.delegate[0] = delegate;
+
+ this.length = length;
+
+ // Caller desires delegate to be 'length' instead of
+ // it's actual length so we will calculate a time scale
+ // If the desired length is longer than delegate's then
+ // we need to feed time in slower, ie: scale < 1
+ if (length != 0) {
+ this.scale = delegate.getLength() / length;
+ } else {
+ this.scale = 0;
+ }
+ }
+
+ @Override
+ public double getLength() {
+ return length;
+ }
+
+ @Override
+ public Tween[] getTweens() {
+ return delegate;
+ }
+
+ @Override
+ public boolean interpolate(double t) {
+ if (t < 0) {
+ return true;
+ }
+ if (length > 0) {
+ t *= scale;
+ } else {
+ t = length;
+ }
+ return delegate[0].interpolate(t);
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[delegate=" + delegate[0] + ", length=" + length + "]";
+ }
+ }
+
+ private static class CallMethod extends AbstractTween {
+
+ private Object target;
+ private Method method;
+ private Object[] args;
+
+ public CallMethod(Object target, String methodName, Object... args) {
+ super(0);
+ if (target == null) {
+ throw new IllegalArgumentException("Target cannot be null.");
+ }
+ this.target = target;
+ this.args = args;
+
+ // Lookup the method
+ if (args == null) {
+ this.method = findMethod(target.getClass(), methodName);
+ } else {
+ this.method = findMethod(target.getClass(), methodName, args);
+ }
+ if (this.method == null) {
+ throw new IllegalArgumentException("Method not found for:" + methodName + " on type:" + target.getClass());
+ }
+ this.method.setAccessible(true);
+ }
+
+ private static Method findMethod(Class type, String name, Object... args) {
+ for (Method m : type.getDeclaredMethods()) {
+ if (!Objects.equals(m.getName(), name)) {
+ continue;
+ }
+ Class[] paramTypes = m.getParameterTypes();
+ if (paramTypes.length != args.length) {
+ continue;
+ }
+ int matches = 0;
+ for (int i = 0; i < args.length; i++) {
+ if (paramTypes[i].isInstance(args[i])
+ || Primitives.wrap(paramTypes[i]).isInstance(args[i])) {
+ matches++;
+ }
+ }
+ if (matches == args.length) {
+ return m;
+ }
+ }
+ if (type.getSuperclass() != null) {
+ return findMethod(type.getSuperclass(), name, args);
+ }
+ return null;
+ }
+
+ @Override
+ protected void doInterpolate(double t) {
+ try {
+ method.invoke(target, args);
+ } catch (IllegalAccessException e) {
+ throw new RuntimeException("Error running method:" + method + " for object:" + target, e);
+ } catch (InvocationTargetException e) {
+ throw new RuntimeException("Error running method:" + method + " for object:" + target, e);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[method=" + method + ", parms=" + Arrays.asList(args) + "]";
+ }
+ }
+
+ private static class CallTweenMethod extends AbstractTween {
+
+ private Object target;
+ private Method method;
+ private Object[] args;
+ private int tIndex = -1;
+ private boolean isFloat = false;
+
+ public CallTweenMethod(double length, Object target, String methodName, Object... args) {
+ super(length);
+ if (target == null) {
+ throw new IllegalArgumentException("Target cannot be null.");
+ }
+ this.target = target;
+
+ // Lookup the method
+ this.method = findMethod(target.getClass(), methodName, args);
+ if (this.method == null) {
+ throw new IllegalArgumentException("Method not found for:" + methodName + " on type:" + target.getClass());
+ }
+ this.method.setAccessible(true);
+
+ // So now setup the real args list
+ this.args = new Object[args.length + 1];
+ if (tIndex == 0) {
+ for (int i = 0; i < args.length; i++) {
+ this.args[i + 1] = args[i];
+ }
+ } else {
+ for (int i = 0; i < args.length; i++) {
+ this.args[i] = args[i];
+ }
+ }
+ }
+
+ private static boolean isFloatType(Class type) {
+ return type == Float.TYPE || type == Float.class;
+ }
+
+ private static boolean isDoubleType(Class type) {
+ return type == Double.TYPE || type == Double.class;
+ }
+
+ private Method findMethod(Class type, String name, Object... args) {
+ for (Method m : type.getDeclaredMethods()) {
+ if (!Objects.equals(m.getName(), name)) {
+ continue;
+ }
+ Class[] paramTypes = m.getParameterTypes();
+ if (paramTypes.length != args.length + 1) {
+ if (log.isLoggable(Level.FINE)) {
+ log.log(Level.FINE, "Param lengths of [" + m + "] differ. method arg count:" + paramTypes.length + " lookging for:" + (args.length + 1));
+ }
+ continue;
+ }
+
+ // We accept the 't' parameter as either first or last
+ // so we'll see which one matches.
+ if (isFloatType(paramTypes[0]) || isDoubleType(paramTypes[0])) {
+ // Try it as the first parameter
+ int matches = 0;
+
+ for (int i = 1; i < paramTypes.length; i++) {
+ if (paramTypes[i].isInstance(args[i - 1])) {
+ matches++;
+ }
+ }
+ if (matches == args.length) {
+ // Then this is our method and this is how we are configured
+ tIndex = 0;
+ isFloat = isFloatType(paramTypes[0]);
+ } else {
+ if (log.isLoggable(Level.FINE)) {
+ log.log(Level.FINE, m + " Leading float check failed because of type mismatches, for:" + m);
+ }
+ }
+ }
+ if (tIndex >= 0) {
+ return m;
+ }
+
+ // Else try it at the end
+ int last = paramTypes.length - 1;
+ if (isFloatType(paramTypes[last]) || isDoubleType(paramTypes[last])) {
+ int matches = 0;
+
+ for (int i = 0; i < last; i++) {
+ if (paramTypes[i].isInstance(args[i])) {
+ matches++;
+ }
+ }
+ if (matches == args.length) {
+ // Then this is our method and this is how we are configured
+ tIndex = last;
+ isFloat = isFloatType(paramTypes[last]);
+ return m;
+ } else {
+ if (log.isLoggable(Level.FINE)) {
+ log.log(Level.FINE, "Trailing float check failed because of type mismatches, for:" + m);
+ }
+ }
+ }
+ }
+ if (type.getSuperclass() != null) {
+ return findMethod(type.getSuperclass(), name, args);
+ }
+ return null;
+ }
+
+ @Override
+ protected void doInterpolate(double t) {
+ try {
+ if (isFloat) {
+ args[tIndex] = (float) t;
+ } else {
+ args[tIndex] = t;
+ }
+ method.invoke(target, args);
+ } catch (IllegalAccessException e) {
+ throw new RuntimeException("Error running method:" + method + " for object:" + target, e);
+ } catch (InvocationTargetException e) {
+ throw new RuntimeException("Error running method:" + method + " for object:" + target, e);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[method=" + method + ", parms=" + Arrays.asList(args) + "]";
+ }
+ }
+}
diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/Action.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/Action.java
new file mode 100644
index 000000000..e4038caff
--- /dev/null
+++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/Action.java
@@ -0,0 +1,70 @@
+package com.jme3.anim.tween.action;
+
+import com.jme3.anim.AnimationMask;
+import com.jme3.anim.tween.Tween;
+
+public abstract class Action implements Tween {
+
+ protected Action[] actions;
+ private double length;
+ private double speed = 1;
+ private AnimationMask mask;
+ private boolean forward = true;
+
+ protected Action(Tween... tweens) {
+ this.actions = new Action[tweens.length];
+ for (int i = 0; i < tweens.length; i++) {
+ Tween tween = tweens[i];
+ if (tween instanceof Action) {
+ this.actions[i] = (Action) tween;
+ } else {
+ this.actions[i] = new BaseAction(tween);
+ }
+ }
+ }
+
+ @Override
+ public double getLength() {
+ return length;
+ }
+
+ protected void setLength(double length) {
+ this.length = length;
+ }
+
+ public double getSpeed() {
+ return speed;
+ }
+
+ public void setSpeed(double speed) {
+ this.speed = speed;
+ if( speed < 0){
+ setForward(false);
+ } else {
+ setForward(true);
+ }
+ }
+
+ public AnimationMask getMask() {
+ return mask;
+ }
+
+ public void setMask(AnimationMask mask) {
+ this.mask = mask;
+ }
+
+ protected boolean isForward() {
+ return forward;
+ }
+
+ protected void setForward(boolean forward) {
+ if(this.forward == forward){
+ return;
+ }
+ this.forward = forward;
+ for (Action action : actions) {
+ action.setForward(forward);
+ }
+
+ }
+}
diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/BaseAction.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/BaseAction.java
new file mode 100644
index 000000000..d2e891343
--- /dev/null
+++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/BaseAction.java
@@ -0,0 +1,38 @@
+package com.jme3.anim.tween.action;
+
+import com.jme3.anim.tween.ContainsTweens;
+import com.jme3.anim.tween.Tween;
+import com.jme3.util.SafeArrayList;
+
+import java.util.Collections;
+import java.util.List;
+
+public class BaseAction extends Action {
+
+ private Tween tween;
+
+ public BaseAction(Tween tween) {
+ this.tween = tween;
+ setLength(tween.getLength());
+ List
+ * wrap(int.class) == Integer.class
+ * wrap(Integer.class) == Integer.class
+ * wrap(String.class) == String.class
+ *
+ */
+ public static AnimChannel
provides controls, such as play, pause,
- * fast forward, etc, for an animation. The animation
- * channel may influence the entire model or specific bones of the model's
- * skeleton. A single model may have multiple animation channels influencing
- * various parts of its body. For example, a character model may have an
- * animation channel for its feet, and another for its torso, and
- * the animations for each channel are controlled independently.
- *
- * @author Kirill Vainer
- */
-public final class AnimChannel {
-
- private static final float DEFAULT_BLEND_TIME = 0.15f;
-
- private AnimControl control;
-
- private BitSet affectedBones;
-
- private Animation animation;
- private Animation blendFrom;
- private float time;
- private float speed;
- private float timeBlendFrom;
- private float blendTime;
- private float speedBlendFrom;
- private boolean notified=false;
-
- private LoopMode loopMode, loopModeBlendFrom;
-
- private float blendAmount = 1f;
- private float blendRate = 0;
-
- AnimChannel(AnimControl control){
- this.control = control;
- }
-
- /**
- * Returns the parent control of this AnimChannel.
- *
- * @return the parent control of this AnimChannel.
- * @see AnimControl
- */
- public AnimControl getControl() {
- return control;
- }
-
- /**
- * @return The name of the currently playing animation, or null if
- * none is assigned.
- *
- * @see AnimChannel#setAnim(java.lang.String)
- */
- public String getAnimationName() {
- return animation != null ? animation.getName() : null;
- }
-
- /**
- * @return The loop mode currently set for the animation. The loop mode
- * determines what will happen to the animation once it finishes
- * playing.
- *
- * For more information, see the LoopMode enum class.
- * @see LoopMode
- * @see AnimChannel#setLoopMode(com.jme3.animation.LoopMode)
- */
- public LoopMode getLoopMode() {
- return loopMode;
- }
-
- /**
- * @param loopMode Set the loop mode for the channel. The loop mode
- * determines what will happen to the animation once it finishes
- * playing.
- *
- * For more information, see the LoopMode enum class.
- * @see LoopMode
- */
- public void setLoopMode(LoopMode loopMode) {
- this.loopMode = loopMode;
- }
-
- /**
- * @return The speed that is assigned to the animation channel. The speed
- * is a scale value starting from 0.0, at 1.0 the animation will play
- * at its default speed.
- *
- * @see AnimChannel#setSpeed(float)
- */
- public float getSpeed() {
- return speed;
- }
-
- /**
- * @param speed Set the speed of the animation channel. The speed
- * is a scale value starting from 0.0, at 1.0 the animation will play
- * at its default speed.
- */
- public void setSpeed(float speed) {
- this.speed = speed;
- if(blendTime>0){
- this.speedBlendFrom = speed;
- blendTime = Math.min(blendTime, animation.getLength() / speed);
- blendRate = 1/ blendTime;
- }
- }
-
- /**
- * @return The time of the currently playing animation. The time
- * starts at 0 and continues on until getAnimMaxTime().
- *
- * @see AnimChannel#setTime(float)
- */
- public float getTime() {
- return time;
- }
-
- /**
- * @param time Set the time of the currently playing animation, the time
- * is clamped from 0 to {@link #getAnimMaxTime()}.
- */
- public void setTime(float time) {
- this.time = FastMath.clamp(time, 0, getAnimMaxTime());
- }
-
- /**
- * @return The length of the currently playing animation, or zero
- * if no animation is playing.
- *
- * @see AnimChannel#getTime()
- */
- public float getAnimMaxTime(){
- return animation != null ? animation.getLength() : 0f;
- }
-
- /**
- * Set the current animation that is played by this AnimChannel.
- * blendTime
seconds with the currently playing animation.
- * Notice that this method will reset the control's speed to 1.0.
- *
- * @param name The name of the animation to play
- * @param blendTime The blend time over which to blend the new animation
- * with the old one. If zero, then no blending will occur and the new
- * animation will be applied instantly.
- */
- public void setAnim(String name, float blendTime){
- if (name == null)
- throw new IllegalArgumentException("name cannot be null");
-
- if (blendTime < 0f)
- throw new IllegalArgumentException("blendTime cannot be less than zero");
-
- Animation anim = control.animationMap.get(name);
- if (anim == null)
- throw new IllegalArgumentException("Cannot find animation named: '"+name+"'");
-
- control.notifyAnimChange(this, name);
-
- if (animation != null && blendTime > 0f){
- this.blendTime = blendTime;
- // activate blending
- blendTime = Math.min(blendTime, anim.getLength() / speed);
- blendFrom = animation;
- timeBlendFrom = time;
- speedBlendFrom = speed;
- loopModeBlendFrom = loopMode;
- blendAmount = 0f;
- blendRate = 1f / blendTime;
- }else{
- blendFrom = null;
- }
-
- animation = anim;
- time = 0;
- speed = 1f;
- loopMode = LoopMode.Loop;
- notified = false;
- }
-
- /**
- * Set the current animation that is played by this AnimChannel.
- * AnimChannel
provides controls, such as play, pause,
+ * fast forward, etc, for an animation. The animation
+ * channel may influence the entire model or specific bones of the model's
+ * skeleton. A single model may have multiple animation channels influencing
+ * various parts of its body. For example, a character model may have an
+ * animation channel for its feet, and another for its torso, and
+ * the animations for each channel are controlled independently.
+ *
+ * @author Kirill Vainer
+ */
+@Deprecated
+public final class AnimChannel {
+
+ private static final float DEFAULT_BLEND_TIME = 0.15f;
+
+ private AnimControl control;
+
+ private BitSet affectedBones;
+
+ private Animation animation;
+ private Animation blendFrom;
+ private float time;
+ private float speed;
+ private float timeBlendFrom;
+ private float blendTime;
+ private float speedBlendFrom;
+ private boolean notified=false;
+
+ private LoopMode loopMode, loopModeBlendFrom;
+
+ private float blendAmount = 1f;
+ private float blendRate = 0;
+
+ public AnimChannel(){
+
+ }
+
+ public AnimChannel(AnimControl control){
+ this.control = control;
+ }
+
+ /**
+ * Returns the parent control of this AnimChannel.
+ *
+ * @return the parent control of this AnimChannel.
+ * @see AnimControl
+ */
+ public AnimControl getControl() {
+ return control;
+ }
+
+ /**
+ * @return The name of the currently playing animation, or null if
+ * none is assigned.
+ *
+ * @see AnimChannel#setAnim(java.lang.String)
+ */
+ public String getAnimationName() {
+ return animation != null ? animation.getName() : null;
+ }
+
+ /**
+ * @return The loop mode currently set for the animation. The loop mode
+ * determines what will happen to the animation once it finishes
+ * playing.
+ *
+ * For more information, see the LoopMode enum class.
+ * @see LoopMode
+ * @see AnimChannel#setLoopMode(com.jme3.animation.LoopMode)
+ */
+ public LoopMode getLoopMode() {
+ return loopMode;
+ }
+
+ /**
+ * @param loopMode Set the loop mode for the channel. The loop mode
+ * determines what will happen to the animation once it finishes
+ * playing.
+ *
+ * For more information, see the LoopMode enum class.
+ * @see LoopMode
+ */
+ public void setLoopMode(LoopMode loopMode) {
+ this.loopMode = loopMode;
+ }
+
+ /**
+ * @return The speed that is assigned to the animation channel. The speed
+ * is a scale value starting from 0.0, at 1.0 the animation will play
+ * at its default speed.
+ *
+ * @see AnimChannel#setSpeed(float)
+ */
+ public float getSpeed() {
+ return speed;
+ }
+
+ /**
+ * @param speed Set the speed of the animation channel. The speed
+ * is a scale value starting from 0.0, at 1.0 the animation will play
+ * at its default speed.
+ */
+ public void setSpeed(float speed) {
+ this.speed = speed;
+ if(blendTime>0){
+ this.speedBlendFrom = speed;
+ blendTime = Math.min(blendTime, animation.getLength() / speed);
+ blendRate = 1/ blendTime;
+ }
+ }
+
+ /**
+ * @return The time of the currently playing animation. The time
+ * starts at 0 and continues on until getAnimMaxTime().
+ *
+ * @see AnimChannel#setTime(float)
+ */
+ public float getTime() {
+ return time;
+ }
+
+ /**
+ * @param time Set the time of the currently playing animation, the time
+ * is clamped from 0 to {@link #getAnimMaxTime()}.
+ */
+ public void setTime(float time) {
+ this.time = FastMath.clamp(time, 0, getAnimMaxTime());
+ }
+
+ /**
+ * @return The length of the currently playing animation, or zero
+ * if no animation is playing.
+ *
+ * @see AnimChannel#getTime()
+ */
+ public float getAnimMaxTime(){
+ return animation != null ? animation.getLength() : 0f;
+ }
+
+ /**
+ * Set the current animation that is played by this AnimChannel.
+ * blendTime
seconds with the currently playing animation.
+ * Notice that this method will reset the control's speed to 1.0.
+ *
+ * @param name The name of the animation to play
+ * @param blendTime The blend time over which to blend the new animation
+ * with the old one. If zero, then no blending will occur and the new
+ * animation will be applied instantly.
+ */
+ public void setAnim(String name, float blendTime){
+ if (name == null)
+ throw new IllegalArgumentException("name cannot be null");
+
+ if (blendTime < 0f)
+ throw new IllegalArgumentException("blendTime cannot be less than zero");
+
+ Animation anim = control.animationMap.get(name);
+ if (anim == null)
+ throw new IllegalArgumentException("Cannot find animation named: '"+name+"'");
+
+ control.notifyAnimChange(this, name);
+
+ if (animation != null && blendTime > 0f){
+ this.blendTime = blendTime;
+ // activate blending
+ blendTime = Math.min(blendTime, anim.getLength() / speed);
+ blendFrom = animation;
+ timeBlendFrom = time;
+ speedBlendFrom = speed;
+ loopModeBlendFrom = loopMode;
+ blendAmount = 0f;
+ blendRate = 1f / blendTime;
+ }else{
+ blendFrom = null;
+ }
+
+ animation = anim;
+ time = 0;
+ speed = 1f;
+ loopMode = LoopMode.Loop;
+ notified = false;
+ }
+
+ /**
+ * Set the current animation that is played by this AnimChannel.
+ * AnimControl
is a Spatial control that allows manipulation
@@ -67,7 +64,9 @@ import java.util.Map.Entry;
* 1) Morph/Pose animation
*
* @author Kirill Vainer
+ * @deprecated use {@link com.jme3.anim.AnimComposer}
*/
+@Deprecated
public final class AnimControl extends AbstractControl implements Cloneable, JmeCloneable {
/**
@@ -108,32 +107,6 @@ public final class AnimControl extends AbstractControl implements Cloneable, Jme
public AnimControl() {
}
- /**
- * Internal use only.
- */
- @Override
- public Control cloneForSpatial(Spatial spatial) {
- try {
- AnimControl clone = (AnimControl) super.clone();
- clone.spatial = spatial;
- clone.channels = new ArrayList
@@ -62,13 +57,14 @@ import java.util.logging.Logger;
* control.getAnim("TheAnim").addTrack(track);
*
*
- * if the emitter has emits 0 particles per seconds emmitAllPArticles will be
- * called on it at time 0 + startOffset. if it he it has more it will start
- * emit normally at time 0 + startOffset.
+ * if the emitter emits 0 particles per second, emitAllPArticles will be
+ * called on it at time 0 + startOffset. if it has more it will start
+ * emitting normally at time 0 + startOffset.
*
*
* @author Nehon
*/
+@Deprecated
public class EffectTrack implements ClonableTrack {
private static final Logger logger = Logger.getLogger(EffectTrack.class.getName());
@@ -132,28 +128,17 @@ public class EffectTrack implements ClonableTrack {
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
}
-
- @Override
- public Control cloneForSpatial(Spatial spatial) {
-
- KillParticleControl c = new KillParticleControl();
- //this control should be removed as it shouldn't have been persisted in the first place
- //In the quest to find the less hackish solution to achieve this,
- //making it remove itself from the spatial in the first update loop when loaded was the less bad.
- c.remove = true;
- c.setSpatial(spatial);
- return c;
-
- }
- };
+ }
//Anim listener that stops the Emmitter when the animation is finished or changed.
private class OnEndListener implements AnimEventListener {
+ @Override
public void onAnimCycleDone(AnimControl control, AnimChannel channel, String animName) {
stop();
}
+ @Override
public void onAnimChange(AnimControl control, AnimChannel channel, String animName) {
}
}
@@ -203,6 +188,7 @@ public class EffectTrack implements ClonableTrack {
* @see Track#setTime(float, float, com.jme3.animation.AnimControl,
* com.jme3.animation.AnimChannel, com.jme3.util.TempVars)
*/
+ @Override
public void setTime(float time, float weight, AnimControl control, AnimChannel channel, TempVars vars) {
if (time >= length) {
@@ -213,7 +199,7 @@ public class EffectTrack implements ClonableTrack {
control.addListener(new OnEndListener());
initialized = true;
}
- //checking fo time to trigger the effect
+ //checking for time to trigger the effect
if (!emitted && time >= startOffset) {
emitted = true;
emitter.setCullHint(CullHint.Dynamic);
@@ -248,6 +234,7 @@ public class EffectTrack implements ClonableTrack {
*
* @return length of the track
*/
+ @Override
public float getLength() {
return length;
}
@@ -340,6 +327,7 @@ public class EffectTrack implements ClonableTrack {
return null;
}
+ @Override
public void cleanUp() {
TrackInfo t = (TrackInfo) emitter.getUserData("TrackInfo");
t.getTracks().remove(this);
@@ -428,9 +416,10 @@ public class EffectTrack implements ClonableTrack {
* @param ex exporter
* @throws IOException exception
*/
+ @Override
public void write(JmeExporter ex) throws IOException {
OutputCapsule out = ex.getCapsule(this);
- //reseting the particle emission rate on the emitter before saving.
+ //reset the particle emission rate on the emitter before saving.
emitter.setParticlesPerSec(particlesPerSeconds);
out.write(emitter, "emitter", null);
out.write(particlesPerSeconds, "particlesPerSeconds", 0);
@@ -446,10 +435,11 @@ public class EffectTrack implements ClonableTrack {
* @param im importer
* @throws IOException Exception
*/
+ @Override
public void read(JmeImporter im) throws IOException {
InputCapsule in = im.getCapsule(this);
this.particlesPerSeconds = in.readFloat("particlesPerSeconds", 0);
- //reading the emitter even if the track will then reference its cloned counter part if it's loaded with the assetManager.
+ //reading the emitter even if the track will then reference its cloned counterpart if it's loaded with the assetManager.
//This also avoid null pointer exception if the model is not loaded via the AssetManager.
emitter = (ParticleEmitter) in.readSavable("emitter", null);
emitter.setParticlesPerSec(0);
diff --git a/jme3-core/src/main/java/com/jme3/animation/LoopMode.java b/jme3-core/src/main/java/com/jme3/animation/LoopMode.java
index ca7b1eb1c..16ca1deb0 100644
--- a/jme3-core/src/main/java/com/jme3/animation/LoopMode.java
+++ b/jme3-core/src/main/java/com/jme3/animation/LoopMode.java
@@ -35,6 +35,7 @@ package com.jme3.animation;
* LoopMode
determines how animations repeat, or if they
* do not repeat.
*/
+@Deprecated
public enum LoopMode {
/**
* The animation will play repeatedly, when it reaches the end
diff --git a/jme3-core/src/main/java/com/jme3/animation/Pose.java b/jme3-core/src/main/java/com/jme3/animation/Pose.java
index fc06d0d07..f5d0e305a 100644
--- a/jme3-core/src/main/java/com/jme3/animation/Pose.java
+++ b/jme3-core/src/main/java/com/jme3/animation/Pose.java
@@ -34,12 +34,14 @@ package com.jme3.animation;
import com.jme3.export.*;
import com.jme3.math.Vector3f;
import com.jme3.util.BufferUtils;
+
import java.io.IOException;
import java.nio.FloatBuffer;
/**
* A pose is a list of offsets that say where a mesh vertices should be for this pose.
*/
+@Deprecated
public final class Pose implements Savable, Cloneable {
private String name;
diff --git a/jme3-core/src/main/java/com/jme3/animation/Skeleton.java b/jme3-core/src/main/java/com/jme3/animation/Skeleton.java
index 904d7a298..651bf06a3 100644
--- a/jme3-core/src/main/java/com/jme3/animation/Skeleton.java
+++ b/jme3-core/src/main/java/com/jme3/animation/Skeleton.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -31,11 +31,13 @@
*/
package com.jme3.animation;
+import com.jme3.anim.Armature;
import com.jme3.export.*;
import com.jme3.math.Matrix4f;
import com.jme3.util.TempVars;
-import com.jme3.util.clone.JmeCloneable;
import com.jme3.util.clone.Cloner;
+import com.jme3.util.clone.JmeCloneable;
+
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@@ -46,14 +48,16 @@ import java.util.List;
* animated matrixes.
*
* @author Kirill Vainer
+ * @deprecated use {@link Armature}
*/
+@Deprecated
public final class Skeleton implements Savable, JmeCloneable {
private Bone[] rootBones;
private Bone[] boneList;
/**
- * Contains the skinning matrices, multiplying it by a vertex effected by a bone
+ * Contains the skinning matrices, multiplying it by a vertex affected by a bone
* will cause it to go to the animated position.
*/
private transient Matrix4f[] skinningMatrixes;
@@ -169,7 +173,7 @@ public final class Skeleton implements Savable, JmeCloneable {
}
/**
- * Saves the current skeleton state as it's binding pose.
+ * Saves the current skeleton state as its binding pose.
*/
public void setBindingPose() {
for (int i = rootBones.length - 1; i >= 0; i--) {
@@ -304,6 +308,7 @@ public final class Skeleton implements Savable, JmeCloneable {
createSkinningMatrices();
for (Bone rootBone : rootBones) {
+ rootBone.reset();
rootBone.update();
rootBone.setBindingPose();
}
diff --git a/jme3-core/src/main/java/com/jme3/animation/SkeletonControl.java b/jme3-core/src/main/java/com/jme3/animation/SkeletonControl.java
index 4cefd721c..06f6927ab 100644
--- a/jme3-core/src/main/java/com/jme3/animation/SkeletonControl.java
+++ b/jme3-core/src/main/java/com/jme3/animation/SkeletonControl.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2017 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -31,25 +31,23 @@
*/
package com.jme3.animation;
+import com.jme3.anim.SkinningControl;
import com.jme3.export.*;
import com.jme3.material.MatParamOverride;
import com.jme3.math.FastMath;
import com.jme3.math.Matrix4f;
-import com.jme3.renderer.RenderManager;
-import com.jme3.renderer.RendererException;
-import com.jme3.renderer.ViewPort;
+import com.jme3.renderer.*;
import com.jme3.scene.*;
import com.jme3.scene.VertexBuffer.Type;
import com.jme3.scene.control.AbstractControl;
-import com.jme3.scene.control.Control;
import com.jme3.scene.mesh.IndexBuffer;
import com.jme3.shader.VarType;
-import com.jme3.util.*;
+import com.jme3.util.SafeArrayList;
+import com.jme3.util.TempVars;
import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
import java.io.IOException;
import java.nio.Buffer;
-import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -60,7 +58,9 @@ import java.util.logging.Logger;
* the mesh
*
* @author Rémy Bouquet Based on AnimControl by Kirill Vainer
+ * @deprecated use {@link SkinningControl}
*/
+@Deprecated
public class SkeletonControl extends AbstractControl implements Cloneable, JmeCloneable {
/**
@@ -145,6 +145,12 @@ public class SkeletonControl extends AbstractControl implements Cloneable, JmeCl
}
private boolean testHardwareSupported(RenderManager rm) {
+
+ //Only 255 bones max supported with hardware skinning
+ if (skeleton.getBoneCount() > 255) {
+ return false;
+ }
+
switchToHardware();
try {
@@ -158,7 +164,7 @@ public class SkeletonControl extends AbstractControl implements Cloneable, JmeCl
/**
* Specifies if hardware skinning is preferred. If it is preferred and
- * supported by GPU, it shall be enabled, if its not preferred, or not
+ * supported by GPU, it shall be enabled, if it's not preferred, or not
* supported by GPU, then it shall be disabled.
*
* @param preferred
@@ -326,7 +332,7 @@ public class SkeletonControl extends AbstractControl implements Cloneable, JmeCl
bpb.clear();
bnb.clear();
- //reseting bind tangents if there is a bind tangent buffer
+ //reset bind tangents if there is a bind tangent buffer
VertexBuffer bindTangents = mesh.getBuffer(Type.BindPoseTangent);
if (bindTangents != null) {
VertexBuffer tangents = mesh.getBuffer(Type.Tangent);
@@ -344,47 +350,6 @@ public class SkeletonControl extends AbstractControl implements Cloneable, JmeCl
}
}
- @Override
- public Control cloneForSpatial(Spatial spatial) {
- Node clonedNode = (Node) spatial;
- SkeletonControl clone = new SkeletonControl();
-
- AnimControl ctrl = spatial.getControl(AnimControl.class);
- if (ctrl != null) {
- // AnimControl is responsible for cloning the skeleton, not
- // SkeletonControl.
- clone.skeleton = ctrl.getSkeleton();
- } else {
- // If there's no AnimControl, create the clone ourselves.
- clone.skeleton = new Skeleton(skeleton);
- }
- clone.hwSkinningDesired = this.hwSkinningDesired;
- clone.hwSkinningEnabled = this.hwSkinningEnabled;
- clone.hwSkinningSupported = this.hwSkinningSupported;
- clone.hwSkinningTested = this.hwSkinningTested;
-
- clone.setSpatial(clonedNode);
-
- // Fix attachments for the cloned node
- for (int i = 0; i < clonedNode.getQuantity(); i++) {
- // go through attachment nodes, apply them to correct bone
- Spatial child = clonedNode.getChild(i);
- if (child instanceof Node) {
- Node clonedAttachNode = (Node) child;
- Bone originalBone = (Bone) clonedAttachNode.getUserData("AttachedBone");
-
- if (originalBone != null) {
- Bone clonedBone = clone.skeleton.getBone(originalBone.getName());
-
- clonedAttachNode.setUserData("AttachedBone", clonedBone);
- clonedBone.setAttachmentsNode(clonedAttachNode);
- }
- }
- }
-
- return clone;
- }
-
@Override
public Object jmeClone() {
return super.jmeClone();
diff --git a/jme3-core/src/main/java/com/jme3/animation/SpatialTrack.java b/jme3-core/src/main/java/com/jme3/animation/SpatialTrack.java
index c770838f0..fc992d2b0 100644
--- a/jme3-core/src/main/java/com/jme3/animation/SpatialTrack.java
+++ b/jme3-core/src/main/java/com/jme3/animation/SpatialTrack.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -31,27 +31,23 @@
*/
package com.jme3.animation;
-import com.jme3.export.InputCapsule;
-import com.jme3.export.JmeExporter;
-import com.jme3.export.JmeImporter;
-import com.jme3.export.OutputCapsule;
+import com.jme3.export.*;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import com.jme3.scene.Spatial;
import com.jme3.util.TempVars;
import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
-
import java.io.IOException;
-import java.util.Arrays;
/**
* This class represents the track for spatial animation.
*
* @author Marcin Roguski (Kaelthas)
*/
-public class SpatialTrack implements Track, JmeCloneable {
-
+@Deprecated
+public class SpatialTrack implements JmeCloneable, Track {
+
/**
* Translations of the track.
*/
@@ -250,9 +246,16 @@ public class SpatialTrack implements Track, JmeCloneable {
return times == null ? 0 : times[times.length - 1] - times[0];
}
+ /**
+ * Create a clone with the same track spatial.
+ *
+ * @return a new track
+ */
@Override
- public Track clone() {
- return (Track) jmeClone();
+ public SpatialTrack clone() {
+ Cloner cloner = new Cloner();
+ cloner.setClonedValue(trackSpatial, trackSpatial);
+ return cloner.clone(this);
}
@Override
@@ -268,24 +271,38 @@ public class SpatialTrack implements Track, JmeCloneable {
return trackSpatial;
}
+ /**
+ * Create a shallow clone for the JME cloner.
+ *
+ * @return a new track
+ */
@Override
- public Object jmeClone() {
- int tablesLength = times.length;
-
- float[] timesCopy = this.times.clone();
- Vector3f[] translationsCopy = this.getTranslations() == null ? null : Arrays.copyOf(this.getTranslations(), tablesLength);
- Quaternion[] rotationsCopy = this.getRotations() == null ? null : Arrays.copyOf(this.getRotations(), tablesLength);
- Vector3f[] scalesCopy = this.getScales() == null ? null : Arrays.copyOf(this.getScales(), tablesLength);
-
- //need to use the constructor here because of the final fields used in this class
- return new SpatialTrack(timesCopy, translationsCopy, rotationsCopy, scalesCopy);
+ public SpatialTrack jmeClone() {
+ try {
+ return (SpatialTrack) super.clone();
+ } catch (CloneNotSupportedException exception) {
+ throw new RuntimeException("Can't clone track", exception);
+ }
}
+ /**
+ * Callback from {@link com.jme3.util.clone.Cloner} to convert this
+ * shallow-cloned track into a deep-cloned one, using the specified cloner
+ * to resolve copied fields.
+ *
+ * @param cloner the cloner currently cloning this control (not null)
+ * @param original the track from which this track was shallow-cloned
+ * (unused)
+ */
@Override
public void cloneFields(Cloner cloner, Object original) {
- this.trackSpatial = cloner.clone(((SpatialTrack) original).trackSpatial);
+ translations = cloner.clone(translations);
+ rotations = cloner.clone(rotations);
+ scales = cloner.clone(scales);
+ trackSpatial = cloner.clone(trackSpatial);
+ times = cloner.clone(times);
}
-
+
@Override
public void write(JmeExporter ex) throws IOException {
OutputCapsule oc = ex.getCapsule(this);
diff --git a/jme3-core/src/main/java/com/jme3/animation/Track.java b/jme3-core/src/main/java/com/jme3/animation/Track.java
index 4eafed06a..7777e8894 100644
--- a/jme3-core/src/main/java/com/jme3/animation/Track.java
+++ b/jme3-core/src/main/java/com/jme3/animation/Track.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009-2012 jMonkeyEngine
+ * Copyright (c) 2009-2018 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -34,6 +34,7 @@ package com.jme3.animation;
import com.jme3.export.Savable;
import com.jme3.util.TempVars;
+@Deprecated
public interface Track extends Savable, Cloneable {
/**
@@ -44,9 +45,9 @@ public interface Track extends Savable, Cloneable {
* given parameters.
*
* @param time The time in the animation
- * @param weight The weight from 0 to 1 on how much to apply the track
- * @param control The control which the track should effect
- * @param channel The channel which the track should effect
+ * @param weight The weight from 0 to 1 on how much to apply the track
+ * @param control The control which the track should affect
+ * @param channel The channel which the track should affect
*/
public void setTime(float time, float weight, AnimControl control, AnimChannel channel, TempVars vars);
diff --git a/jme3-core/src/main/java/com/jme3/animation/TrackInfo.java b/jme3-core/src/main/java/com/jme3/animation/TrackInfo.java
index 7ee927cd3..93fd6a88e 100644
--- a/jme3-core/src/main/java/com/jme3/animation/TrackInfo.java
+++ b/jme3-core/src/main/java/com/jme3/animation/TrackInfo.java
@@ -31,13 +31,10 @@
*/
package com.jme3.animation;
-import com.jme3.export.InputCapsule;
-import com.jme3.export.JmeExporter;
-import com.jme3.export.JmeImporter;
-import com.jme3.export.OutputCapsule;
-import com.jme3.export.Savable;
+import com.jme3.export.*;
import com.jme3.util.clone.Cloner;
import com.jme3.util.clone.JmeCloneable;
+
import java.io.IOException;
import java.util.ArrayList;
@@ -50,6 +47,7 @@ import java.util.ArrayList;
*
* @author Nehon
*/
+@Deprecated
public class TrackInfo implements Savable, JmeCloneable {
ArrayList